ConfigurationObjects.h

Go to the documentation of this file.

//
//  Copyright (c) 2019 Rally Tactical Systems, Inc.
//  All rights reserved.
//
 
#ifndef ConfigurationObjects_h
#define ConfigurationObjects_h
 
#include "Platform.h"
#include "EngageConstants.h"
 
#include <iostream>
#include <cstddef>
#include <cstdint>
#include <chrono>
#include <vector>
#include <string>
 
#include <nlohmann/json.hpp>
 
#ifndef WIN32
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wunused-function"
#endif
 
#if !defined(ENGAGE_IGNORE_COMPILER_UNUSED_WARNING)
    #if defined(__GNUC__)
        #define ENGAGE_IGNORE_COMPILER_UNUSED_WARNING __attribute__((unused))
    #else
        #define ENGAGE_IGNORE_COMPILER_UNUSED_WARNING
    #endif
#endif  // ENGAGE_IGNORE_COMPILER_UNUSED_WARNING
 
// We'll use a different namespace depending on whether we're building the RTS core code
// or if this is being included in an app-land project.
#if defined(RTS_CORE_BUILD)
namespace ConfigurationObjects
#else
namespace AppConfigurationObjects
#endif
{
    static const char *ENGAGE_CONFIGURATION_OBJECT_ATTACHED_OBJECT = "_attached";
 
    //-----------------------------------------------------------
    #pragma pack(push, 1)
        typedef struct _DataSeriesHeader_t
        {
            uint8_t     t;
 
            uint32_t    ts;
 
            uint8_t     it;
 
            uint8_t     im;
 
            uint8_t     vt;
 
            uint8_t     ss;
        } DataSeriesHeader_t;
 
        typedef struct _DataElementUint8_t
        {
            uint8_t     ofs;
            uint8_t     val;
        } DataElementUint8_t;
 
        typedef struct _DataElementUnint16_t
        {
            uint8_t     ofs;
            uint16_t    val;
        } DataElementUnint16_t;
 
        typedef struct _DataElementUnint32_t
        {
            uint8_t     ofs;
            uint32_t    val;
        } DataElementUnint32_t;
 
        typedef struct _DataElementUnint64_t
        {
            uint8_t     ofs;
            uint64_t    val;
        } DataElementUnint64_t;
    #pragma pack(pop)
 
    typedef enum
    {
        invalid = 0,
        uint8 = 1,
        uint16 = 2,
        uint32 = 3,
        uint64 = 4
    } DataSeriesValueType_t;
 
    typedef enum
    {
        unknown = 0,
        heartRate = 1,
        skinTemp = 2,
        coreTemp = 3,
        hydration = 4,
        bloodOxygenation = 5,
        fatigueLevel = 6,
        taskEffectiveness = 7
    } HumanBiometricsTypes_t;
 
    //-----------------------------------------------------------
 
    static FILE *_internalFileOpener(const char *fn, const char *mode)
    {
        FILE *fp = nullptr;
 
        #ifndef WIN32
            fp = fopen(fn, mode);
        #else
            if(fopen_s(&fp, fn, mode) != 0)
            {
                fp = nullptr;
            }
        #endif
 
        return fp;
    }
 
    #define JSON_SERIALIZED_CLASS(_cn) \
        class _cn; \
        static void to_json(nlohmann::json& j, const _cn& p); \
        static void from_json(const nlohmann::json& j, _cn& p);
 
    #define IMPLEMENT_JSON_DOCUMENTATION(_cn) \
        public: \
        static void document(const char *path = nullptr) \
        { \
            _cn   example; \
            example.initForDocumenting(); \
            std::string theJson = example.serialize(3); \
            std::cout << "------------------------------------------------" << std::endl \
                      << #_cn << std::endl \
                      << theJson << std::endl \
                      << "------------------------------------------------" << std::endl; \
            \
            if(path != nullptr && path[0] != 0) \
            { \
                std::string fn = path; \
                fn.append("/"); \
                fn.append(#_cn); \
                fn.append(".json");  \
                \
                FILE *fp = _internalFileOpener(fn.c_str(), "wt");\
                \
                if(fp != nullptr) \
                { \
                    fputs(theJson.c_str(), fp); \
                    fclose(fp); \
                } \
                else \
                { \
                    std::cout << "ERROR: Cannot write to " << fn << std::endl; \
                } \
            } \
        } \
        static const char *className() \
        { \
            return #_cn; \
        }
 
    #define IMPLEMENT_JSON_SERIALIZATION() \
        public: \
        bool deserialize(const char *s) \
        { \
            try \
            { \
                if(s != nullptr && s[0] != 0) \
                { \
                    from_json(nlohmann::json::parse(s), *this); \
                } \
                else \
                { \
                    return false; \
                } \
            } \
            catch(...) \
            { \
                return false; \
            } \
            return true; \
        } \
        \
        std::string serialize(const int indent = -1) \
        { \
            try \
            { \
                nlohmann::json j; \
                to_json(j, *this); \
                return j.dump(indent); \
            } \
            catch(...) \
            { \
                return std::string("{}"); \
            } \
        }
 
    #define IMPLEMENT_WRAPPED_JSON_SERIALIZATION(_cn) \
        public: \
        std::string serializeWrapped(const int indent = -1) \
        { \
            try \
            { \
                nlohmann::json j; \
                to_json(j, *this); \
                \
                std::string rc; \
                char firstChar[2]; \
                firstChar[0] = #_cn[0]; \
                firstChar[1] = 0; \
                firstChar[0] = tolower(firstChar[0]); \
                rc.assign("{\""); \
                rc.append(firstChar); \
                rc.append((#_cn) + 1); \
                rc.append("\":"); \
                rc.append(j.dump(indent)); \
                rc.append("}"); \
                \
                return rc; \
            } \
            catch(...) \
            { \
                return std::string("{}"); \
            } \
        }
 
    #define TOJSON_IMPL(__var) \
        {#__var, p.__var}
 
    #define FROMJSON_IMPL_SIMPLE(__var) \
        getOptional(#__var, p.__var, j)
 
    #define FROMJSON_IMPL(__var, __type, __default) \
        getOptional<__type>(#__var, p.__var, j, __default)
 
    #define TOJSON_BASE_IMPL() \
        to_json(j, (ConfigurationObjectBase&)p)
 
    #define FROMJSON_BASE_IMPL() \
        from_json(j, (ConfigurationObjectBase&)p);
 
 
    //-----------------------------------------------------------
    static std::string EMPTY_STRING;
 
    template<class T>
    static void getOptional(const char *name, T& v, const nlohmann::json& j, T def)
    {
        try
        {
            if(j.contains(name))
            {
                j.at(name).get_to(v);
            }
            else
            {
                v = def;    
            }
        }
        catch(...)
        {
            v = def;
        }
    }
 
    template<class T>
    static void getOptional(const char *name, T& v, const nlohmann::json& j)
    {
        try
        {
            if(j.contains(name))
            {
                j.at(name).get_to(v);
            }
        }
        catch(...)
        {
        }
    }
 
    template<class T>
    static void getOptionalWithIndicator(const char *name, T& v, const nlohmann::json& j, T def, bool *wasFound)
    {
        try
        {
            if(j.contains(name))
            {
                j.at(name).get_to(v);
                *wasFound = true;
            }
            else
            {
                v = def;
                *wasFound = false;
            }
        }
        catch(...)
        {
            v = def;
            *wasFound = false;
        }
    }
 
    template<class T>
    static void getOptionalWithIndicator(const char *name, T& v, const nlohmann::json& j, bool *wasFound)
    {
        try
        {
            if(j.contains(name))
            {
                j.at(name).get_to(v);
                *wasFound = true;
            }
            else
            {
                *wasFound = false;    
            }
        }
        catch(...)
        {
            *wasFound = false;
        }
    }
 
    class ConfigurationObjectBase
    {
    public:
        ConfigurationObjectBase()
        {
            _documenting = false;
        }
 
        virtual ~ConfigurationObjectBase()
        {
        }
 
        virtual void initForDocumenting()
        {
            _documenting = true;
        }
 
        virtual std::string toString()
        {
            return std::string("");
        }
 
        inline virtual bool isDocumenting() const
        {
            return _documenting;
        }
 
        nlohmann::json      _attached;
 
    protected:
        bool                _documenting;
    };
 
    static void to_json(nlohmann::json& j, const ConfigurationObjectBase& p)
    {
        try
        {
            if(p._attached != nullptr)
            {
                j[ENGAGE_CONFIGURATION_OBJECT_ATTACHED_OBJECT] = p._attached;
            }
        }
        catch(...)
        {
        }
    }
    static void from_json(const nlohmann::json& j, ConfigurationObjectBase& p)
    {
        try
        {
            if(j.contains(ENGAGE_CONFIGURATION_OBJECT_ATTACHED_OBJECT))
            {
                p._attached = j.at(ENGAGE_CONFIGURATION_OBJECT_ATTACHED_OBJECT);
            }
        }
        catch(...)
        {
        }
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(KvPair)
    class KvPair : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(KvPair)
 
    public:
        std::string                     key;
 
        std::string                     value;
        
        KvPair()
        {
            clear();
        }
 
        void clear()
        {
            key.clear();
            value.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const KvPair& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(key),
            TOJSON_IMPL(value)
        };
    }
    static void from_json(const nlohmann::json& j, KvPair& p)
    {
        p.clear();
        getOptional<std::string>("key", p.key, j, EMPTY_STRING);
        getOptional<std::string>("tags", p.value, j, EMPTY_STRING);
    }    
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(TuningSettings)
    class TuningSettings : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(TuningSettings)
 
    public:
        uint32_t                    maxPooledRtpMb;
 
        uint32_t                    maxPooledRtpObjects;
 
        uint32_t                    maxActiveRtpObjects;
 
 
        uint32_t                    maxPooledBlobMb;
 
        uint32_t                    maxPooledBlobObjects;
 
        uint32_t                    maxActiveBlobObjects;
 
 
        uint32_t                    maxPooledBufferMb;
 
        uint32_t                    maxPooledBufferObjects;
 
        uint32_t                    maxActiveBufferObjects;
 
        uint32_t                    maxActiveRtpProcessors;
 
        TuningSettings()
        {
            clear();
        }
 
        void clear()
        {
            maxPooledRtpMb = 0;
            maxPooledRtpObjects = 0;
            maxActiveRtpObjects = 0;
 
            maxPooledBlobMb = 0;
            maxPooledBlobObjects = 0;
            maxActiveBlobObjects = 0;
 
            maxPooledBufferMb = 0;
            maxPooledBufferObjects = 0;
            maxActiveBufferObjects = 0;
 
            maxActiveRtpProcessors = 0;
        }
 
        virtual void initForDocumenting()
        {
            clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const TuningSettings& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(maxPooledRtpMb),
            TOJSON_IMPL(maxPooledRtpObjects),
            TOJSON_IMPL(maxActiveRtpObjects),
 
            TOJSON_IMPL(maxPooledBlobMb),
            TOJSON_IMPL(maxPooledBlobObjects),
            TOJSON_IMPL(maxActiveBlobObjects),
 
            TOJSON_IMPL(maxPooledBufferMb),
            TOJSON_IMPL(maxPooledBufferObjects),
            TOJSON_IMPL(maxActiveBufferObjects),
 
            TOJSON_IMPL(maxActiveRtpProcessors)
        };
    }
    static void from_json(const nlohmann::json& j, TuningSettings& p)
    {
        p.clear();
        FROMJSON_IMPL(maxPooledRtpMb, uint32_t, 0);
        FROMJSON_IMPL(maxPooledRtpObjects, uint32_t, 0);
        FROMJSON_IMPL(maxActiveRtpObjects, uint32_t, 0);
 
        FROMJSON_IMPL(maxPooledBlobMb, uint32_t, 0);
        FROMJSON_IMPL(maxPooledBlobObjects, uint32_t, 0);
        FROMJSON_IMPL(maxActiveBlobObjects, uint32_t, 0);
 
        FROMJSON_IMPL(maxPooledBufferMb, uint32_t, 0);
        FROMJSON_IMPL(maxPooledBufferObjects, uint32_t, 0);
        FROMJSON_IMPL(maxActiveBufferObjects, uint32_t, 0);
 
        FROMJSON_IMPL(maxActiveRtpProcessors, uint32_t, 0);
    }    
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(FipsCryptoSettings)
    class FipsCryptoSettings : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(FipsCryptoSettings)
 
    public:
        bool                        enabled;
 
        std::string                 path;
 
        bool                        debug;
 
        std::string                 curves;
 
        std::string                 ciphers;
 
        FipsCryptoSettings()
        {
            clear();
        }
 
        void clear()
        {
            enabled = false;
            path.clear();
            debug = false;
            curves.clear();
            ciphers.clear();
        }
 
        virtual void initForDocumenting()
        {
            clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const FipsCryptoSettings& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(path),
            TOJSON_IMPL(debug),
            TOJSON_IMPL(curves),
            TOJSON_IMPL(ciphers)
        };
    }
    static void from_json(const nlohmann::json& j, FipsCryptoSettings& p)
    {
        p.clear();
        FROMJSON_IMPL_SIMPLE(enabled);
        FROMJSON_IMPL_SIMPLE(path);
        FROMJSON_IMPL_SIMPLE(debug);
        FROMJSON_IMPL_SIMPLE(curves);
        FROMJSON_IMPL_SIMPLE(ciphers);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(WatchdogSettings)
    class WatchdogSettings : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(WatchdogSettings)
 
    public:
        bool                        enabled;
 
        int                         intervalMs;
 
        int                         hangDetectionMs;
 
        bool                        abortOnHang;
 
        int                         slowExecutionThresholdMs;
 
        WatchdogSettings()
        {
            clear();
        }
 
        void clear()
        {
            enabled = true;
            intervalMs = 5000;
            hangDetectionMs = 2000;
            abortOnHang = true;
            slowExecutionThresholdMs = 100;
        }
 
        virtual void initForDocumenting()
        {
            clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const WatchdogSettings& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(intervalMs),
            TOJSON_IMPL(hangDetectionMs),
            TOJSON_IMPL(abortOnHang),
            TOJSON_IMPL(slowExecutionThresholdMs)
        };
    }
    static void from_json(const nlohmann::json& j, WatchdogSettings& p)
    {
        p.clear();
        getOptional<bool>("enabled", p.enabled, j, true);
        getOptional<int>("intervalMs", p.intervalMs, j, 5000);
        getOptional<int>("hangDetectionMs", p.hangDetectionMs, j, 2000);
        getOptional<bool>("abortOnHang", p.abortOnHang, j, true);
        getOptional<int>("slowExecutionThresholdMs", p.slowExecutionThresholdMs, j, 100);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(FileRecordingRequest)
    class FileRecordingRequest : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(FileRecordingRequest)
 
    public:
        std::string                 id;
        std::string                 fileName;
        uint32_t                    maxMs;
 
        FileRecordingRequest()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            fileName.clear();
            maxMs = 60000;
        }
 
        virtual void initForDocumenting()
        {
            clear();
            id = "1-2-3-4-5-6-7-8-9";
            fileName = "/tmp/test.wav";
            maxMs = 10000;
        }
    };
 
    static void to_json(nlohmann::json& j, const FileRecordingRequest& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(fileName),
            TOJSON_IMPL(maxMs)
        };
    }
    static void from_json(const nlohmann::json& j, FileRecordingRequest& p)
    {
        p.clear();
        j.at("id").get_to(p.id);
        j.at("fileName").get_to(p.fileName);
        getOptional<uint32_t>("maxMs", p.maxMs, j, 60000);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(Feature)
    class Feature : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(Feature)
 
    public:
        std::string                 id;
        std::string                 name;
        std::string                 description;
        std::string                 comments;
        int                         count;
        int                         used;       // NOTE: Ignored during deserialization!
 
        Feature()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            name.clear();
            description.clear();
            comments.clear();
            count = 0;
            used = 0;
        }
 
        virtual void initForDocumenting()
        {
            clear();
            id = "{af9540d1-3e86-4fa6-8b80-e26daecb61ab}";
            name = "A sample feature";
            description = "This is an example of a feature";
            comments = "These are comments for this feature";
            count = 42;
            used = 16;
        }
    };
 
    static void to_json(nlohmann::json& j, const Feature& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(name),
            TOJSON_IMPL(description),
            TOJSON_IMPL(comments),
            TOJSON_IMPL(count),
            TOJSON_IMPL(used)
        };
    }
    static void from_json(const nlohmann::json& j, Feature& p)
    {
        p.clear();
        j.at("id").get_to(p.id);
        getOptional("name", p.name, j);
        getOptional("description", p.description, j);
        getOptional("comments", p.comments, j);
        getOptional("count", p.count, j, 0);
 
        // NOTE: Not deserialized!
        //getOptional("used", p.used, j, 0);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(Featureset)
    class Featureset : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(Featureset)
 
    public:
        std::string                 signature;
        bool                        lockToDeviceId;
        std::vector<Feature>        features;
 
        Featureset()
        {
            clear();
        }
 
        void clear()
        {
            signature.clear();
            lockToDeviceId = false;
            features.clear();
        }
 
        virtual void initForDocumenting()
        {
            clear();
            signature = "c39df3f36c6444e686e47e70fc45cf91e6ed2d8de62d4a1e89f507d567ff48aaabb1a70e54b44377b46fc4a1a2e319e5b77e4abffc444db98f8eb55d709aad5f";
            lockToDeviceId = false;
        }
    };
 
    static void to_json(nlohmann::json& j, const Featureset& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(signature),
            TOJSON_IMPL(lockToDeviceId),
            TOJSON_IMPL(features)
        };
    }
    static void from_json(const nlohmann::json& j, Featureset& p)
    {
        p.clear();
        getOptional("signature", p.signature, j);
        getOptional<bool>("lockToDeviceId", p.lockToDeviceId, j, false);
        getOptional<std::vector<Feature>>("features", p.features, j);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(Agc)
    class Agc : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(Agc)
 
    public:
        bool enabled;
 
        int minLevel;
 
        int maxLevel;
 
        int compressionGainDb;
 
        bool enableLimiter;
 
        int targetLevelDb;
 
        Agc()
        {
            clear();
        }
 
        void clear()
        {
            enabled = false;
            minLevel = 0;
            maxLevel = 255;
            compressionGainDb = 25;
            enableLimiter = false;
            targetLevelDb = 3;
        }
    };
 
    static void to_json(nlohmann::json& j, const Agc& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(minLevel),
            TOJSON_IMPL(maxLevel),
            TOJSON_IMPL(compressionGainDb),
            TOJSON_IMPL(enableLimiter),
            TOJSON_IMPL(targetLevelDb)
        };
    }
    static void from_json(const nlohmann::json& j, Agc& p)
    {
        p.clear();
        getOptional<bool>("enabled", p.enabled, j, false);
        getOptional<int>("minLevel", p.minLevel, j, 0);
        getOptional<int>("maxLevel", p.maxLevel, j, 255);
        getOptional<int>("compressionGainDb", p.compressionGainDb, j, 25);
        getOptional<bool>("enableLimiter", p.enableLimiter, j, false);
        getOptional<int>("targetLevelDb", p.targetLevelDb, j, 3);
    }    
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RtpPayloadTypeTranslation)
    class RtpPayloadTypeTranslation : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RtpPayloadTypeTranslation)
 
    public:
        uint16_t        external;
 
        uint16_t        engage; 
 
        RtpPayloadTypeTranslation()
        {
            clear();
        }
 
        void clear()
        {
            external = 0;
            engage = 0;
        }
 
        bool matches(const RtpPayloadTypeTranslation& other)
        {
            return ( (external == other.external) && (engage == other.engage) );
        }
    };
 
    static void to_json(nlohmann::json& j, const RtpPayloadTypeTranslation& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(external),
            TOJSON_IMPL(engage)
        };
    }
    static void from_json(const nlohmann::json& j, RtpPayloadTypeTranslation& p)
    {
        p.clear();
        getOptional<uint16_t>("external", p.external, j);
        getOptional<uint16_t>("engage", p.engage, j);
    }    
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(NetworkInterfaceDevice)
    class NetworkInterfaceDevice : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(NetworkInterfaceDevice)
 
    public:
        std::string                 name;
        std::string                 friendlyName;
        std::string                 description;
        int                         family;
        std::string                 address;
        bool                        available;
        bool                        isLoopback;
        bool                        supportsMulticast;
        std::string                 hardwareAddress;
 
        NetworkInterfaceDevice()
        {
            clear();
        }
 
        void clear()
        {
            name.clear();
            friendlyName.clear();
            description.clear();
            family = -1;
            address.clear();
            available = false;
            isLoopback = false;
            supportsMulticast = false;
            hardwareAddress.clear();
        }
 
        virtual void initForDocumenting()
        {
            clear();
            name = "en0";
            friendlyName = "Wi-Fi";
            description = "A wi-fi adapter";
            family = 1;
            address = "127.0.0.1";
            available = true;
            isLoopback = true;
            supportsMulticast = false;
            hardwareAddress = "DE:AD:BE:EF:01:02:03";
        }
    };
 
    static void to_json(nlohmann::json& j, const NetworkInterfaceDevice& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(name),
            TOJSON_IMPL(friendlyName),
            TOJSON_IMPL(description),
            TOJSON_IMPL(family),
            TOJSON_IMPL(address),
            TOJSON_IMPL(available),
            TOJSON_IMPL(isLoopback),
            TOJSON_IMPL(supportsMulticast),
            TOJSON_IMPL(hardwareAddress)
        };
    }
    static void from_json(const nlohmann::json& j, NetworkInterfaceDevice& p)
    {
        p.clear();
        getOptional("name", p.name, j);
        getOptional("friendlyName", p.friendlyName, j);
        getOptional("description", p.description, j);
        getOptional("family", p.family, j, -1);
        getOptional("address", p.address, j);
        getOptional("available", p.available, j, false);
        getOptional("isLoopback", p.isLoopback, j, false);
        getOptional("supportsMulticast", p.supportsMulticast, j, false);
        getOptional("hardwareAddress", p.hardwareAddress, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(ListOfNetworkInterfaceDevice)
    class ListOfNetworkInterfaceDevice : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(ListOfNetworkInterfaceDevice)
 
    public:
        std::vector<NetworkInterfaceDevice> list;
 
        ListOfNetworkInterfaceDevice()
        {
            clear();
        }
 
        void clear()
        {
            list.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const ListOfNetworkInterfaceDevice& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(list)
        };
    }
    static void from_json(const nlohmann::json& j, ListOfNetworkInterfaceDevice& p)
    {
        p.clear();
        getOptional<std::vector<NetworkInterfaceDevice>>("list", p.list, j);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RtpHeader)
    class RtpHeader : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RtpHeader)
 
    public:
 
        int         pt;
 
        bool        marker;
 
        uint16_t    seq;
 
        uint32_t    ssrc;
 
        uint32_t    ts;
 
        RtpHeader()
        {
            clear();
        }
 
        void clear()
        {
            pt = -1;
            marker = false;
            seq = 0;
            ssrc = 0;
            ts = 0;
        }
 
        virtual void initForDocumenting()
        {
            clear();
            pt = 0;
            marker = false;
            seq = 123;
            ssrc = 12345678;
            ts = 87654321;
        }
    };
 
    static void to_json(nlohmann::json& j, const RtpHeader& p)
    {
        if(p.pt != -1)
        {
            j = nlohmann::json{
                TOJSON_IMPL(pt),
                TOJSON_IMPL(marker),
                TOJSON_IMPL(seq),
                TOJSON_IMPL(ssrc),
                TOJSON_IMPL(ts)
            };
        }
    }
    static void from_json(const nlohmann::json& j, RtpHeader& p)
    {
        p.clear();
        getOptional<int>("pt", p.pt, j, -1);
        getOptional<bool>("marker", p.marker, j, false);
        getOptional<uint16_t>("seq", p.seq, j, 0);
        getOptional<uint32_t>("ssrc", p.ssrc, j, 0);
        getOptional<uint32_t>("ts", p.ts, j, 0);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(Rfc4733Event)
    class Rfc4733Event : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(Rfc4733Event)
 
    public:
 
        int         id;
 
        bool        end;
 
        int         reserved;
 
        int         volume;
 
        int         duration;
 
        Rfc4733Event()
        {
            clear();
        }
 
        void clear()
        {
            id = -1;
            end = false;
            reserved = 0;
            volume = 0;
            duration = 0;
        }
 
        virtual void initForDocumenting()
        {
            clear();
            id = 0;
            end = false;
            reserved = 0;
            volume = 0;
            duration = 0;
        }
    };
 
    static void to_json(nlohmann::json& j, const Rfc4733Event& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(end),
            TOJSON_IMPL(reserved),
            TOJSON_IMPL(volume),
            TOJSON_IMPL(duration)
        };
    }
    static void from_json(const nlohmann::json& j, Rfc4733Event& p)
    {
        p.clear();
        getOptional<int>("id", p.id, j, -1);
        getOptional<bool>("end", p.end, j, false);
        getOptional<int>("reserved", p.reserved, j, 0);
        getOptional<int>("volume", p.volume, j, 0);
        getOptional<int>("duration", p.duration, j, 0);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(BlobInfo)
    class BlobInfo : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(BlobInfo)
 
    public:
        typedef enum
        {
            bptUndefined                    = 0,
 
            bptAppTextUtf8                  = 1,
 
            bptJsonTextUtf8                 = 2,
 
            bptAppBinary                    = 3,
 
            bptEngageBinaryHumanBiometrics  = 4,
 
            bptAppMimeMessage               = 5,
 
            bptRfc4733Events               = 6,
 
            bptEngageInternal               = 42
        } PayloadType_t;
 
        size_t          size;
 
        std::string     source;
 
        std::string     target;
 
        PayloadType_t   payloadType;
 
        RtpHeader       rtpHeader;
 
        std::string     txnId;
 
        int             txnTimeoutSecs;
 
        BlobInfo()
        {
            clear();
        }
 
        void clear()
        {
            size = 0;
            source.clear();
            target.clear();
            rtpHeader.clear();
            payloadType = PayloadType_t::bptUndefined;
            txnId.clear();
            txnTimeoutSecs = 0;
        }
 
        virtual void initForDocumenting()
        {
            clear();
            rtpHeader.initForDocumenting();
        }
    };
 
    static void to_json(nlohmann::json& j, const BlobInfo& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(size),
            TOJSON_IMPL(source),
            TOJSON_IMPL(target),
            TOJSON_IMPL(rtpHeader),
            TOJSON_IMPL(payloadType),
            TOJSON_IMPL(txnId),
            TOJSON_IMPL(txnTimeoutSecs)
        };
    }
    static void from_json(const nlohmann::json& j, BlobInfo& p)
    {
        p.clear();
        getOptional<size_t>("size", p.size, j, 0);
        getOptional<std::string>("source", p.source, j, EMPTY_STRING);
        getOptional<std::string>("target", p.target, j, EMPTY_STRING);
        getOptional<RtpHeader>("rtpHeader", p.rtpHeader, j);
        getOptional<BlobInfo::PayloadType_t>("payloadType", p.payloadType, j, BlobInfo::PayloadType_t::bptUndefined);
        getOptional<std::string>("txnId", p.txnId, j, EMPTY_STRING);
        getOptional<int>("txnTimeoutSecs", p.txnTimeoutSecs, j, 0);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(TxAudioUri)
    class TxAudioUri : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(TxAudioUri)
 
    public:
        std::string     uri;
 
        int             repeatCount;
 
        TxAudioUri()
        {
            clear();
        }
 
        void clear()
        {
            uri.clear();
            repeatCount = 0;
        }
 
        virtual void initForDocumenting()
        {
        }
    };
 
    static void to_json(nlohmann::json& j, const TxAudioUri& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(uri),
            TOJSON_IMPL(repeatCount)
        };
    }
    static void from_json(const nlohmann::json& j, TxAudioUri& p)
    {
        p.clear();
        getOptional<std::string>("uri", p.uri, j, EMPTY_STRING);
        getOptional<int>("repeatCount", p.repeatCount, j, 0);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(AdvancedTxParams)
    class AdvancedTxParams : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(AdvancedTxParams)
 
    public:
 
        uint16_t        flags;
 
        uint8_t         priority;
 
        uint16_t        subchannelTag;
 
        bool            includeNodeId;
 
        std::string     alias;
 
        bool            muted;
 
        uint32_t        txId;
 
        TxAudioUri      audioUri;        
 
        uint16_t        aliasSpecializer;
 
        bool            receiverRxMuteForAliasSpecializer;
 
        bool            reBegin;
 
        AdvancedTxParams()
        {
            clear();
        }
 
        void clear()
        {
            flags = 0;
            priority = 0;
            subchannelTag = 0;
            includeNodeId = false;
            alias.clear();
            muted = false;
            txId = 0;
            audioUri.clear();
            aliasSpecializer = 0;
            receiverRxMuteForAliasSpecializer = false;
            reBegin = false;
        }
 
        virtual void initForDocumenting()
        {
        }
    };
 
    static void to_json(nlohmann::json& j, const AdvancedTxParams& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(flags),
            TOJSON_IMPL(priority),
            TOJSON_IMPL(subchannelTag),
            TOJSON_IMPL(includeNodeId),
            TOJSON_IMPL(alias),
            TOJSON_IMPL(muted),
            TOJSON_IMPL(txId),
            TOJSON_IMPL(audioUri),
            TOJSON_IMPL(aliasSpecializer),
            TOJSON_IMPL(receiverRxMuteForAliasSpecializer),
            TOJSON_IMPL(reBegin)
        };
    }
    static void from_json(const nlohmann::json& j, AdvancedTxParams& p)
    {
        p.clear();
        getOptional<uint16_t>("flags", p.flags, j, 0);
        getOptional<uint8_t>("priority", p.priority, j, 0);
        getOptional<uint16_t>("subchannelTag", p.subchannelTag, j, 0);
        getOptional<bool>("includeNodeId", p.includeNodeId, j, false);
        getOptional<std::string>("alias", p.alias, j, EMPTY_STRING);
        getOptional<bool>("muted", p.muted, j, false);
        getOptional<uint32_t>("txId", p.txId, j, 0);
        getOptional<TxAudioUri>("audioUri", p.audioUri, j);
        getOptional<uint16_t>("aliasSpecializer", p.aliasSpecializer, j, 0);
        getOptional<bool>("receiverRxMuteForAliasSpecializer", p.receiverRxMuteForAliasSpecializer, j, false);
        getOptional<bool>("reBegin", p.reBegin, j, false);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(Identity)
    class Identity : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(Identity)
 
    public:
        std::string     nodeId;
 
        std::string     userId;
 
        std::string     displayName;
 
        std::string     avatar;
 
        Identity()
        {
            clear();
        }
 
        void clear()
        {
            nodeId.clear();
            userId.clear();
            displayName.clear();
            avatar.clear();
        }
 
        virtual void initForDocumenting()
        {
        }
    };
 
    static void to_json(nlohmann::json& j, const Identity& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(nodeId),
            TOJSON_IMPL(userId),
            TOJSON_IMPL(displayName),
            TOJSON_IMPL(avatar)
        };
    }
    static void from_json(const nlohmann::json& j, Identity& p)
    {
        p.clear();
        getOptional<std::string>("nodeId", p.nodeId, j);
        getOptional<std::string>("userId", p.userId, j);
        getOptional<std::string>("displayName", p.displayName, j);
        getOptional<std::string>("avatar", p.avatar, j);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(Location)
    class Location : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(Location)
 
    public:
        constexpr static double INVALID_LOCATION_VALUE = -999.999;
 
        uint32_t                    ts;
 
        double                      latitude;
 
        double                      longitude;
 
        double                      altitude;
 
        double                      direction;
 
        double                      speed;
 
        Location()
        {
            clear();
        }
 
        void clear()
        {
            ts = 0;
            latitude = INVALID_LOCATION_VALUE;
            longitude = INVALID_LOCATION_VALUE;
            altitude = INVALID_LOCATION_VALUE;
            direction = INVALID_LOCATION_VALUE;
            speed = INVALID_LOCATION_VALUE;
        }
 
        virtual void initForDocumenting()
        {
            clear();
 
            ts = 123456;
            latitude = 123.456;
            longitude = 456.789;
            altitude = 123;
            direction = 1;
            speed = 1234;
        }
    };
 
    static void to_json(nlohmann::json& j, const Location& p)
    {
        if(p.latitude != Location::INVALID_LOCATION_VALUE && p.longitude != Location::INVALID_LOCATION_VALUE)
        {
            j = nlohmann::json{
                TOJSON_IMPL(latitude),
                TOJSON_IMPL(longitude),
            };
 
            if(p.ts != 0) j["ts"] = p.ts;
            if(p.altitude != Location::INVALID_LOCATION_VALUE) j["altitude"] = p.altitude;
            if(p.speed != Location::INVALID_LOCATION_VALUE) j["speed"] = p.speed;
            if(p.direction != Location::INVALID_LOCATION_VALUE) j["direction"] = p.direction;
        }
    }
    static void from_json(const nlohmann::json& j, Location& p)
    {
        p.clear();
        getOptional<uint32_t>("ts", p.ts, j, 0);
        j.at("latitude").get_to(p.latitude);
        j.at("longitude").get_to(p.longitude);
        getOptional<double>("altitude", p.altitude, j, Location::INVALID_LOCATION_VALUE);
        getOptional<double>("direction", p.direction, j, Location::INVALID_LOCATION_VALUE);
        getOptional<double>("speed", p.speed, j, Location::INVALID_LOCATION_VALUE);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(Power)
    class Power : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(Power)
 
    public:
 
        int     source;
 
        int     state;
 
        int     level;
 
        Power()
        {
            clear();
        }
 
        void clear()
        {
            source = 0;
            state = 0;
            level = 0;
        }
 
        virtual void initForDocumenting()
        {
        }
    };
 
    static void to_json(nlohmann::json& j, const Power& p)
    {
        if(p.source != 0 && p.state != 0 && p.level != 0)
        {
            j = nlohmann::json{
                TOJSON_IMPL(source),
                TOJSON_IMPL(state),
                TOJSON_IMPL(level)
            };
        }
    }
    static void from_json(const nlohmann::json& j, Power& p)
    {
        p.clear();
        getOptional<int>("source", p.source, j, 0);
        getOptional<int>("state", p.state, j, 0);
        getOptional<int>("level", p.level, j, 0);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(Connectivity)
    class Connectivity : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(Connectivity)
 
    public:
        int     type;
 
        int     strength;
 
        int     rating;
 
        Connectivity()
        {
            clear();
        }
 
        void clear()
        {
            type = 0;
            strength = 0;
            rating = 0;
        }
 
        virtual void initForDocumenting()
        {
            clear();
 
            type = 1;
            strength = 2;
            rating = 3;
        }
    };
 
    static void to_json(nlohmann::json& j, const Connectivity& p)
    {
        if(p.type != 0)
        {
            j = nlohmann::json{
                TOJSON_IMPL(type),
                TOJSON_IMPL(strength),
                TOJSON_IMPL(rating)
            };
        }
    }
    static void from_json(const nlohmann::json& j, Connectivity& p)
    {
        p.clear();
        getOptional<int>("type", p.type, j, 0);
        getOptional<int>("strength", p.strength, j, 0);
        getOptional<int>("rating", p.rating, j, 0);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(PresenceDescriptorGroupItem)
    class PresenceDescriptorGroupItem : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(PresenceDescriptorGroupItem)
 
    public:
        std::string     groupId;
 
        std::string     alias;
 
        uint16_t        status;
 
        PresenceDescriptorGroupItem()
        {
            clear();
        }
 
        void clear()
        {
            groupId.clear();
            alias.clear();
            status = 0;
        }
 
        virtual void initForDocumenting()
        {
            groupId = "{123-456}";
            alias = "MYALIAS";
            status = 0;
        }
    };
 
    static void to_json(nlohmann::json& j, const PresenceDescriptorGroupItem& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(groupId),
            TOJSON_IMPL(alias),
            TOJSON_IMPL(status)
        };
    }
    static void from_json(const nlohmann::json& j, PresenceDescriptorGroupItem& p)
    {
        p.clear();
        getOptional<std::string>("groupId", p.groupId, j);
        getOptional<std::string>("alias", p.alias, j);
        getOptional<uint16_t>("status", p.status, j);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(PresenceDescriptor)
    class PresenceDescriptor : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(PresenceDescriptor)
 
    public:
 
        bool                        self;
 
        uint32_t                    ts;
 
        uint32_t                    nextUpdate;
 
        Identity                    identity;
 
        std::string                 comment;
 
        uint32_t                    disposition;
 
        std::vector<PresenceDescriptorGroupItem>        groupAliases;
 
        Location                    location;
 
        std::string                 custom;
 
        bool                        announceOnReceive;
 
        Connectivity                connectivity;
 
        Power                       power;
 
        PresenceDescriptor()
        {
            clear();
        }
 
        void clear()
        {
            self = false;
            ts = 0;
            nextUpdate = 0;
            identity.clear();
            comment.clear();
            disposition = 0;
            groupAliases.clear();
            location.clear();
            custom.clear();
            announceOnReceive = false;
            connectivity.clear();
            power.clear();
        }
 
        virtual void initForDocumenting()
        {
            clear();
 
            self = true;
            ts = 123;
            nextUpdate = 0;
            identity.initForDocumenting();
            comment = "This is a comment";
            disposition = 123;
 
            PresenceDescriptorGroupItem gi;
            gi.initForDocumenting();
            groupAliases.push_back(gi);
 
            location.initForDocumenting();
            custom = "{}";
            announceOnReceive = true;
            connectivity.initForDocumenting();
            power.initForDocumenting();
        }
    };
 
    static void to_json(nlohmann::json& j, const PresenceDescriptor& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(ts),
            TOJSON_IMPL(nextUpdate),
            TOJSON_IMPL(identity),
            TOJSON_IMPL(comment),
            TOJSON_IMPL(disposition),
            TOJSON_IMPL(groupAliases),
            TOJSON_IMPL(location),
            TOJSON_IMPL(custom),
            TOJSON_IMPL(announceOnReceive),
            TOJSON_IMPL(connectivity),
            TOJSON_IMPL(power)
        };
 
        if(!p.comment.empty()) j["comment"] = p.comment;
        if(!p.custom.empty()) j["custom"] = p.custom;
 
        if(p.self)
        {
            j["self"] = true;
        }
    }
    static void from_json(const nlohmann::json& j, PresenceDescriptor& p)
    {
        p.clear();
        getOptional<bool>("self", p.self, j);
        getOptional<uint32_t>("ts", p.ts, j);
        getOptional<uint32_t>("nextUpdate", p.nextUpdate, j);
        getOptional<Identity>("identity", p.identity, j);
        getOptional<std::string>("comment", p.comment, j);
        getOptional<uint32_t>("disposition", p.disposition, j);
        getOptional<std::vector<PresenceDescriptorGroupItem>>("groupAliases", p.groupAliases, j);
        getOptional<Location>("location", p.location, j);
        getOptional<std::string>("custom", p.custom, j);
        getOptional<bool>("announceOnReceive", p.announceOnReceive, j);
        getOptional<Connectivity>("connectivity", p.connectivity, j);
        getOptional<Power>("power", p.power, j);
    }
 
    typedef enum
    {
        priBestEffort   = 0,
 
        priSignaling    = 1,
 
        priVideo        = 2,
 
        priVoice        = 3
    } TxPriority_t;
 
    typedef enum
    {
        arpIpv4Only       = 4,
 
        arpIpv6Only       = 6,
 
        arpIpv4ThenIpv6   = 46,
 
        arpIpv6ThenIpv4   = 64
    } AddressResolutionPolicy_t;
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(NetworkTxOptions)
    class NetworkTxOptions : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(NetworkTxOptions)
 
    public:
        TxPriority_t    priority;
 
        int             ttl;
 
        NetworkTxOptions()
        {
            clear();
        }
 
        void clear()
        {
            priority = priVoice;
            ttl = 1;
        }
 
        virtual void initForDocumenting()
        {
        }
    };
 
    static void to_json(nlohmann::json& j, const NetworkTxOptions& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(priority),
            TOJSON_IMPL(ttl)
        };
    }
    static void from_json(const nlohmann::json& j, NetworkTxOptions& p)
    {
        p.clear();
        getOptional<TxPriority_t>("priority", p.priority, j, TxPriority_t::priVoice);
        getOptional<int>("ttl", p.ttl, j, 1);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(TcpNetworkTxOptions)
    class TcpNetworkTxOptions : public NetworkTxOptions
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(TcpNetworkTxOptions)
 
    public:
        TcpNetworkTxOptions()
        {
            clear();
        }
 
        void clear()
        {
            priority = priVoice;
            ttl = -1;
        }
 
        virtual void initForDocumenting()
        {
        }
    };
 
    static void to_json(nlohmann::json& j, const TcpNetworkTxOptions& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(priority),
            TOJSON_IMPL(ttl)
        };
    }
    static void from_json(const nlohmann::json& j, TcpNetworkTxOptions& p)
    {
        p.clear();
        getOptional<TxPriority_t>("priority", p.priority, j, TxPriority_t::priVoice);
        getOptional<int>("ttl", p.ttl, j, -1);
    }
 
    typedef enum
    {
        ifIpUnspec             = 0,
 
        ifIp4                  = 4,
 
        ifIp6                  = 6
    } IpFamilyType_t;
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(NetworkAddress)
    class NetworkAddress : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(NetworkAddress)
 
    public:
        std::string     address;
 
        int             port;
 
        NetworkAddress()
        {
            clear();
        }
 
        void clear()
        {
            address.clear();
            port = 0;
        }
 
        bool matches(const NetworkAddress& other)
        {
            if(address.compare(other.address) != 0)
            {
                return false;
            }
 
            if(port != other.port)
            {
                return false;
            }
 
            return true;
        }
    };
 
    static void to_json(nlohmann::json& j, const NetworkAddress& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(address),
            TOJSON_IMPL(port)
        };
    }
    static void from_json(const nlohmann::json& j, NetworkAddress& p)
    {
        p.clear();
        getOptional<std::string>("address", p.address, j);
        getOptional<int>("port", p.port, j);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(NetworkAddressRxTx)
    class NetworkAddressRxTx : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(NetworkAddressRxTx)
 
    public:
        NetworkAddress          rx;
 
        NetworkAddress          tx;
 
        NetworkAddressRxTx()
        {
            clear();
        }
 
        void clear()
        {
            rx.clear();
            tx.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const NetworkAddressRxTx& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(rx),
            TOJSON_IMPL(tx)
        };
    }
    static void from_json(const nlohmann::json& j, NetworkAddressRxTx& p)
    {
        p.clear();
        getOptional<NetworkAddress>("rx", p.rx, j);
        getOptional<NetworkAddress>("tx", p.tx, j);
    }
 
    typedef enum
    {
        graptPermissive = 0,
 
        graptStrict = 1
    } GroupRestrictionAccessPolicyType_t;
 
    static bool isValidGroupRestrictionAccessPolicyType(GroupRestrictionAccessPolicyType_t t)
    {
        return (t == GroupRestrictionAccessPolicyType_t::graptPermissive ||
                t == GroupRestrictionAccessPolicyType_t::graptStrict );
    }
 
    typedef enum
    {
        rtUndefined = 0,
 
        rtWhitelist = 1,
 
        rtBlacklist = 2
    } RestrictionType_t;
 
    static bool isValidRestrictionType(RestrictionType_t t)
    {
        return (t == RestrictionType_t::rtUndefined ||
                t == RestrictionType_t::rtWhitelist ||
                t == RestrictionType_t::rtBlacklist );
    }
 
    typedef enum
    {
        retGroupId = 0,
 
        retGroupIdPattern = 1,
 
        retGenericAccessTagPattern = 2,
 
        retCertificateSerialNumberPattern = 3,
 
        retCertificateFingerprintPattern = 4,
 
        retCertificateSubjectPattern = 5,
 
        retCertificateIssuerPattern = 6
    } RestrictionElementType_t;    
 
    static bool isValidRestrictionElementType(RestrictionElementType_t t)
    {
        return (t == RestrictionElementType_t::retGroupId ||
                t == RestrictionElementType_t::retGroupIdPattern ||
                t == RestrictionElementType_t::retGenericAccessTagPattern ||
                t == RestrictionElementType_t::retCertificateSerialNumberPattern ||
                t == RestrictionElementType_t::retCertificateFingerprintPattern ||
                t == RestrictionElementType_t::retCertificateSubjectPattern ||
                t == RestrictionElementType_t::retCertificateIssuerPattern);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(NetworkAddressRestrictionList)
    class NetworkAddressRestrictionList : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(NetworkAddressRestrictionList)
 
    public:
        RestrictionType_t                   type;
 
        std::vector<NetworkAddressRxTx>     elements;
 
        NetworkAddressRestrictionList()
        {
            clear();
        }
 
        void clear()
        {
            type = RestrictionType_t::rtUndefined;
            elements.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const NetworkAddressRestrictionList& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(type),
            TOJSON_IMPL(elements)
        };
    }
    static void from_json(const nlohmann::json& j, NetworkAddressRestrictionList& p)
    {
        p.clear();
        getOptional<RestrictionType_t>("type", p.type, j, RestrictionType_t::rtUndefined);
        getOptional<std::vector<NetworkAddressRxTx>>("elements", p.elements, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(StringRestrictionList)
    class StringRestrictionList : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(StringRestrictionList)
 
    public:
        RestrictionType_t                   type;
 
        RestrictionElementType_t            elementsType;
 
        std::vector<std::string>            elements;
 
        StringRestrictionList()
        {
            type = RestrictionType_t::rtUndefined;
            elementsType = RestrictionElementType_t::retGroupId;
            clear();
        }
 
        void clear()
        {
            elements.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const StringRestrictionList& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(type),
            TOJSON_IMPL(elementsType),
            TOJSON_IMPL(elements)
        };
    }
    static void from_json(const nlohmann::json& j, StringRestrictionList& p)
    {
        p.clear();
        getOptional<RestrictionType_t>("type", p.type, j, RestrictionType_t::rtUndefined);
        getOptional<RestrictionElementType_t>("elementsType", p.elementsType, j, RestrictionElementType_t::retGroupId);
        getOptional<std::vector<std::string>>("elements", p.elements, j);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(PacketCapturer)
    class PacketCapturer : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(PacketCapturer)
 
    public:
        bool            enabled;
        uint32_t        maxMb;
        std::string     filePrefix;
 
        PacketCapturer()
        {
            clear();
        }
 
        void clear()
        {
            enabled = false;
            maxMb = 10;
            filePrefix.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const PacketCapturer& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(maxMb),
            TOJSON_IMPL(filePrefix)
        };
    }
    static void from_json(const nlohmann::json& j, PacketCapturer& p)
    {
        p.clear();
        getOptional<bool>("enabled", p.enabled, j, false);
        getOptional<uint32_t>("maxMb", p.maxMb, j, 10);
        getOptional<std::string>("filePrefix", p.filePrefix, j, EMPTY_STRING);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(TransportImpairment)
    class TransportImpairment : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(TransportImpairment)
 
    public:
        int     applicationPercentage;
        int     jitterMs;
        int     lossPercentage;
        int     errorPercentage;
 
        TransportImpairment()
        {
            clear();
        }
 
        void clear()
        {
            applicationPercentage = 0;
            jitterMs = 0;
            lossPercentage = 0;
            errorPercentage = 0;
        }
    };
 
    static void to_json(nlohmann::json& j, const TransportImpairment& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(applicationPercentage),
            TOJSON_IMPL(jitterMs),
            TOJSON_IMPL(lossPercentage),
            TOJSON_IMPL(errorPercentage)
        };
    }
    static void from_json(const nlohmann::json& j, TransportImpairment& p)
    {
        p.clear();
        getOptional<int>("applicationPercentage", p.applicationPercentage, j, 0);
        getOptional<int>("jitterMs", p.jitterMs, j, 0);
        getOptional<int>("lossPercentage", p.lossPercentage, j, 0);
        getOptional<int>("errorPercentage", p.errorPercentage, j, 0);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(NsmNetworking)
    class NsmNetworking : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(NsmNetworking)
 
    public:        
        std::string                         address;
        int                                 port;
        int                                 ttl;
        TxPriority_t                        priority;
        int                                 txOversend;
        TransportImpairment                 rxImpairment;
        TransportImpairment                 txImpairment;
        std::string                         cryptoPassword;
        int                                 maxUdpPayloadBytes;
 
        NsmNetworking()
        {
            clear();
        }
 
        void clear()
        {
            address.clear();
            port = 0;
            ttl = 1;
            priority = TxPriority_t::priVoice;
            txOversend = 0;
            rxImpairment.clear();
            txImpairment.clear();
            cryptoPassword.clear();
            maxUdpPayloadBytes = 800;
        }
    };
 
    static void to_json(nlohmann::json& j, const NsmNetworking& p)
    {
        nlohmann::json pathJson;
        to_json(pathJson, p.address);
        j = nlohmann::json{
            TOJSON_IMPL(port),
            TOJSON_IMPL(ttl),
            TOJSON_IMPL(priority),
            TOJSON_IMPL(txOversend),
            TOJSON_IMPL(rxImpairment),
            TOJSON_IMPL(txImpairment),
            TOJSON_IMPL(cryptoPassword),
            TOJSON_IMPL(maxUdpPayloadBytes)
        };
    }
    static void from_json(const nlohmann::json& j, NsmNetworking& p)
    {
        p.clear();
        getOptional<std::string>("address", p.address, j);
        getOptional<int>("port", p.port, j, 8513);
        getOptional<int>("ttl", p.ttl, j, 1);
        getOptional<TxPriority_t>("priority", p.priority, j, TxPriority_t::priVoice);
        getOptional<int>("txOversend", p.txOversend, j, 0);
        getOptional<TransportImpairment>("rxImpairment", p.rxImpairment, j);
        getOptional<TransportImpairment>("txImpairment", p.txImpairment, j);
        getOptional("cryptoPassword", p.cryptoPassword, j, EMPTY_STRING);
        getOptional<int>("maxUdpPayloadBytes", p.maxUdpPayloadBytes, j, 800);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(NsmNodeResource)
    class NsmNodeResource : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(NsmNodeResource)
 
    public:
        std::string                     id;
        int                             priority;
 
        NsmNodeResource()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            priority = -1;
        }
    };
 
    static void to_json(nlohmann::json& j, const NsmNodeResource& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(priority)
        };
    }
    static void from_json(const nlohmann::json& j, NsmNodeResource& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j);
        getOptional<int>("priority", p.priority, j, -1);
    }
 
    static void nsmConfigurationResourcesFromJson(const nlohmann::json& j, std::vector<NsmNodeResource>& out)
    {
        out.clear();
        if (!j.contains("resources") || !j["resources"].is_array())
        {
            return;
        }
        for (const auto& el : j["resources"])
        {
            if (!el.is_object())
            {
                continue;
            }
            NsmNodeResource nr;
            nr.clear();
            getOptional<std::string>("id", nr.id, el);
            getOptional<int>("priority", nr.priority, el, -1);
            if (!nr.id.empty())
            {
                out.push_back(nr);
            }
        }
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(NsmConfiguration)
    class NsmConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(NsmConfiguration)
 
    public:
 
        std::string                         id;
        bool                                favorUptime;
        NsmNetworking                       networking;
        std::vector<NsmNodeResource>        resources;
        int                                 tokenStart;
        int                                 tokenEnd;
        int                                 intervalSecs;
        int                                 transitionSecsFactor;
        int                                 internalMultiplier;
        int                                 goingActiveRandomDelayMs;
        bool                                logCommandOutput;
 
        NsmConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            favorUptime = false;
            networking.clear();
            resources.clear();
            tokenStart = 1000000;
            tokenEnd = 2000000;
            intervalSecs = 1;
            transitionSecsFactor = 3;
            internalMultiplier = 1;
            goingActiveRandomDelayMs = 500;
            logCommandOutput = false;
        }
    };
 
    static void to_json(nlohmann::json& j, const NsmConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(favorUptime),
            TOJSON_IMPL(networking),
            TOJSON_IMPL(resources),
            TOJSON_IMPL(tokenStart),
            TOJSON_IMPL(tokenEnd),
            TOJSON_IMPL(intervalSecs),
            TOJSON_IMPL(transitionSecsFactor),
            TOJSON_IMPL(internalMultiplier),
            TOJSON_IMPL(goingActiveRandomDelayMs),
            TOJSON_IMPL(logCommandOutput),
        };
    }
    static void from_json(const nlohmann::json& j, NsmConfiguration& p)
    {
        p.clear();
        getOptional("id", p.id, j);
        getOptional<bool>("favorUptime", p.favorUptime, j, false);
        getOptional<NsmNetworking>("networking", p.networking, j);
        nsmConfigurationResourcesFromJson(j, p.resources);
        getOptional<int>("tokenStart", p.tokenStart, j, 1000000);
        getOptional<int>("tokenEnd", p.tokenEnd, j, 2000000);
        getOptional<int>("intervalSecs", p.intervalSecs, j, 1);
        getOptional<int>("transitionSecsFactor", p.transitionSecsFactor, j, 3);
        getOptional<int>("internalMultiplier", p.internalMultiplier, j, 1);
        getOptional<int>("goingActiveRandomDelayMs", p.goingActiveRandomDelayMs, j, 500);
        getOptional<bool>("logCommandOutput", p.logCommandOutput, j, false);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(Rallypoint)
    class Rallypoint : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(Rallypoint)
 
    public:
        typedef enum
        {
            rppTlsTcp    = 0,
 
            rppTlsWs      = 1,
 
            rppInvalid    = -1
        } RpProtocol_t;
 
        NetworkAddress              host;
 
        std::string                 certificate;
 
        std::string                 certificateKey;
 
        bool                        verifyPeer;
 
        bool                        allowSelfSignedCertificate;
 
        std::vector<std::string>    caCertificates;
 
        int                         transactionTimeoutMs;
 
        bool                        disableMessageSigning;
 
        int                         connectionTimeoutSecs;
 
        TcpNetworkTxOptions         tcpTxOptions;
 
        std::string                 sni;
 
 
        RpProtocol_t                protocol;
 
        std::string                 path;
 
        std::string                 additionalProtocols;
 
 
        Rallypoint()
        {
            clear();
        }
 
        void clear()
        {
            host.clear();
            certificate.clear();
            certificateKey.clear();
            caCertificates.clear();
            verifyPeer = false;
            transactionTimeoutMs = 0;
            disableMessageSigning = false;
            connectionTimeoutSecs = 0;
            tcpTxOptions.clear();
            sni.clear();
            protocol = rppTlsTcp;
            path.clear();
            additionalProtocols.clear();
        }
 
        bool matches(const Rallypoint& other)
        {
            if(!host.matches(other.host))
            {
                return false;
            }
 
            if(protocol != other.protocol)
            {
                return false;
            }
 
            if(path.compare(other.path) != 0)
            {
                return false;
            }
 
            if(certificate.compare(other.certificate) != 0)
            {
                return false;
            }
 
            if(certificateKey.compare(other.certificateKey) != 0)
            {
                return false;
            }
 
            if(verifyPeer != other.verifyPeer)
            {
                return false;
            }
 
            if(allowSelfSignedCertificate != other.allowSelfSignedCertificate)
            {
                return false;
            }
 
            if(caCertificates.size() != other.caCertificates.size())
            {
                return false;
            }
 
            for(size_t x = 0; x < caCertificates.size(); x++)
            {
                bool found = false;
 
                for(size_t y = 0; y < other.caCertificates.size(); y++)
                {
                    if(caCertificates[x].compare(other.caCertificates[y]) == 0)
                    {
                        found = true;
                        break;
                    }
                }
 
                if(!found)
                {
                    return false;
                }
            }
 
            if(transactionTimeoutMs != other.transactionTimeoutMs)
            {
                return false;
            }
 
            if(disableMessageSigning != other.disableMessageSigning)
            {
                return false;
            }
            if(connectionTimeoutSecs != other.connectionTimeoutSecs)
            {
                return false;
            }
            if(tcpTxOptions.priority != other.tcpTxOptions.priority)
            {
                return false;
            }   
            if(sni.compare(other.sni) != 0)
            {
                return false;
            }
 
            return true;
        }
    };
 
    static void to_json(nlohmann::json& j, const Rallypoint& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(host),
            TOJSON_IMPL(certificate),
            TOJSON_IMPL(certificateKey),
            TOJSON_IMPL(verifyPeer),
            TOJSON_IMPL(allowSelfSignedCertificate),
            TOJSON_IMPL(caCertificates),
            TOJSON_IMPL(transactionTimeoutMs),
            TOJSON_IMPL(disableMessageSigning),
            TOJSON_IMPL(connectionTimeoutSecs),
            TOJSON_IMPL(tcpTxOptions),
            TOJSON_IMPL(sni),
            TOJSON_IMPL(protocol),
            TOJSON_IMPL(path),
            TOJSON_IMPL(additionalProtocols)
        };
    }
 
    static void from_json(const nlohmann::json& j, Rallypoint& p)
    {
        p.clear();
        j.at("host").get_to(p.host);
        getOptional("certificate", p.certificate, j);
        getOptional("certificateKey", p.certificateKey, j);
        getOptional<bool>("verifyPeer", p.verifyPeer, j, true);
        getOptional<bool>("allowSelfSignedCertificate", p.allowSelfSignedCertificate, j, false);
        getOptional<std::vector<std::string>>("caCertificates", p.caCertificates, j);
        getOptional<int>("transactionTimeoutMs", p.transactionTimeoutMs, j, 0);
        getOptional<bool>("disableMessageSigning", p.disableMessageSigning, j, false);
        getOptional<int>("connectionTimeoutSecs", p.connectionTimeoutSecs, j, 0);
        getOptional<TcpNetworkTxOptions>("tcpTxOptions", p.tcpTxOptions, j);
        getOptional<std::string>("sni", p.sni, j);
        getOptional<Rallypoint::RpProtocol_t>("protocol", p.protocol, j, Rallypoint::RpProtocol_t::rppTlsTcp);
        getOptional<std::string>("path", p.path, j);
        getOptional<std::string>("additionalProtocols", p.additionalProtocols, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RallypointCluster)
    class RallypointCluster : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RallypointCluster)
 
    public:
        typedef enum
        {
            csRoundRobin    = 0,
 
            csFailback      = 1
        } ConnectionStrategy_t;
 
        ConnectionStrategy_t                connectionStrategy;
 
        std::vector<Rallypoint>             rallypoints;
 
        int                                 rolloverSecs;
 
        int                                 connectionTimeoutSecs;
 
        int                                 transactionTimeoutMs;
 
        RallypointCluster()
        {
            clear();
        }
 
        void clear()
        {
            connectionStrategy = csRoundRobin;
            rallypoints.clear();
            rolloverSecs = 10;
            connectionTimeoutSecs = 5;
            transactionTimeoutMs = 10000;
        }
    };
 
    static void to_json(nlohmann::json& j, const RallypointCluster& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(connectionStrategy),
            TOJSON_IMPL(rallypoints),
            TOJSON_IMPL(rolloverSecs),
            TOJSON_IMPL(connectionTimeoutSecs),
            TOJSON_IMPL(transactionTimeoutMs)            
        };
    }
    static void from_json(const nlohmann::json& j, RallypointCluster& p)
    {
        p.clear();
        getOptional<RallypointCluster::ConnectionStrategy_t>("connectionStrategy", p.connectionStrategy, RallypointCluster::ConnectionStrategy_t::csRoundRobin);
        getOptional<std::vector<Rallypoint>>("rallypoints", p.rallypoints, j);
        getOptional<int>("rolloverSecs", p.rolloverSecs, j, 10);
        getOptional<int>("connectionTimeoutSecs", p.connectionTimeoutSecs, j, 5);
        getOptional<int>("transactionTimeoutMs", p.transactionTimeoutMs, j, 10000);        
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(NetworkDeviceDescriptor)
    class NetworkDeviceDescriptor : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(NetworkDeviceDescriptor)
 
    public:
        int             deviceId;
 
        std::string     name;
 
        std::string     manufacturer;
 
        std::string     model;
 
        std::string     hardwareId;
 
        std::string     serialNumber;
 
        std::string     type;
 
        std::string     extra;
 
        NetworkDeviceDescriptor()
        {
            clear();
        }
 
        void clear()
        {
            deviceId = 0;
 
            name.clear();
            manufacturer.clear();
            model.clear();
            hardwareId.clear();
            serialNumber.clear();
            type.clear();
            extra.clear();
        }
 
        virtual std::string toString()
        {
            char buff[2048];
 
            snprintf(buff, sizeof(buff), "deviceId=%d, name=%s, manufacturer=%s, model=%s, hardwareId=%s, serialNumber=%s, type=%s, extra=%s",
                        deviceId,
                        name.c_str(),
                        manufacturer.c_str(),
                        model.c_str(),
                        hardwareId.c_str(),
                        serialNumber.c_str(),
                        type.c_str(),
                        extra.c_str());
 
            return std::string(buff);
        }
    };
 
    static void to_json(nlohmann::json& j, const NetworkDeviceDescriptor& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(deviceId),
            TOJSON_IMPL(name),
            TOJSON_IMPL(manufacturer),
            TOJSON_IMPL(model),
            TOJSON_IMPL(hardwareId),
            TOJSON_IMPL(serialNumber),
            TOJSON_IMPL(type),
            TOJSON_IMPL(extra)
        };
    }
    static void from_json(const nlohmann::json& j, NetworkDeviceDescriptor& p)
    {
        p.clear();
        getOptional<int>("deviceId", p.deviceId, j, 0);
        getOptional("name", p.name, j);
        getOptional("manufacturer", p.manufacturer, j);
        getOptional("model", p.model, j);
        getOptional("hardwareId", p.hardwareId, j);
        getOptional("serialNumber", p.serialNumber, j);
        getOptional("type", p.type, j);
        getOptional("extra", p.extra, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(AudioGate)
    class AudioGate : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(AudioGate)
 
    public:
        bool            enabled;
 
        bool            useVad;
 
        uint32_t        hangMs;
 
        uint32_t        windowMin;
 
        uint32_t        windowMax;
 
        double          coefficient;
 
 
        AudioGate()
        {
            clear();
        }
 
        void clear()
        {
            enabled = false;
            useVad = false;
            hangMs = 1500;
            windowMin = 25;
            windowMax = 125;
            coefficient = 1.75;
        }
    };
 
    static void to_json(nlohmann::json& j, const AudioGate& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(useVad),
            TOJSON_IMPL(hangMs),
            TOJSON_IMPL(windowMin),
            TOJSON_IMPL(windowMax),
            TOJSON_IMPL(coefficient)            
        };
    }
    static void from_json(const nlohmann::json& j, AudioGate& p)
    {
        p.clear();
        getOptional<bool>("enabled", p.enabled, j, false);
        getOptional<bool>("useVad", p.useVad, j, false);
        getOptional<uint32_t>("hangMs", p.hangMs, j, 1500);
        getOptional<uint32_t>("windowMin", p.windowMin, j, 25);
        getOptional<uint32_t>("windowMax", p.windowMax, j, 125);
        getOptional<double>("coefficient", p.coefficient, j, 1.75);
    }    
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(TxAudio)
    class TxAudio : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(TxAudio)
 
    public:
        typedef enum
        {
            ctExternal      = -1,
            
            ctUnknown       = 0,
 
            /* G.711 */
            ctG711ulaw      = 1,
 
            ctG711alaw      = 2,
 
 
            /* GSM */
            ctGsm610        = 3,
 
 
            /* G.729 */
            ctG729a         = 4,
 
 
            /* PCM */
            ctPcm           = 5,
 
            // AMR Narrowband */
            ctAmrNb4750     = 10,
 
            ctAmrNb5150     = 11,
 
            ctAmrNb5900     = 12,
 
            ctAmrNb6700     = 13,
 
            ctAmrNb7400     = 14,
 
            ctAmrNb7950     = 15,
 
            ctAmrNb10200    = 16,
 
            ctAmrNb12200    = 17,
 
 
            /* Opus */
            ctOpus6000      = 20,
 
            ctOpus8000      = 21,
 
            ctOpus10000     = 22,
 
            ctOpus12000     = 23,
 
            ctOpus14000     = 24,
 
            ctOpus16000     = 25,
 
            ctOpus18000     = 26,
 
            ctOpus20000     = 27,
 
            ctOpus22000     = 28,
 
            ctOpus24000     = 29,
 
 
            /* Speex */
            ctSpxNb2150     = 30,
 
            ctSpxNb3950     = 31,
 
            ctSpxNb5950     = 32,
 
            ctSpxNb8000     = 33,
 
            ctSpxNb11000    = 34,
 
            ctSpxNb15000    = 35,
 
            ctSpxNb18200    = 36,
 
            ctSpxNb24600    = 37,
 
 
            /* Codec2 */
            ctC2450         = 40,
 
            ctC2700         = 41,
 
            ctC21200        = 42,
 
            ctC21300        = 43,
 
            ctC21400        = 44,
 
            ctC21600        = 45,
 
            ctC22400        = 46,
 
            ctC23200        = 47,
 
 
            /* MELPe */
            ctMelpe600      = 50,
 
            ctMelpe1200     = 51,
 
            ctMelpe2400     = 52,
 
            /* CVSD */
            ctCvsd          = 60
        } TxCodec_t;
 
        typedef enum
        {
            hetEngageStandard      = 0,
            
            hetNatoStanga5643      = 1
        } HeaderExtensionType_t;        
 
        bool            enabled;
 
        TxCodec_t       encoder;
 
        std::string     encoderName;
 
        int             framingMs;
 
        int             blockCount;
        
        bool            fdx;
 
        bool            noHdrExt;
 
        HeaderExtensionType_t hdrExtType;
 
        int             maxTxSecs;
 
        int             extensionSendInterval;
 
        int             initialHeaderBurst;
 
        int             trailingHeaderBurst;
 
        int             startTxNotifications;
 
        int             customRtpPayloadType;
 
        uint32_t        internalKey;
 
        bool            resetRtpOnTx;
 
        bool                enableSmoothing;
 
        bool                dtx;
 
        int                 smoothedHangTimeMs;
 
        TxAudio()
        {
            clear();
        }
 
        void clear()
        {
            enabled = true;
            encoder = TxAudio::TxCodec_t::ctUnknown;
            encoderName.clear();
            framingMs = 60;
            blockCount = 0;
            fdx = false;
            noHdrExt = false;
            maxTxSecs = 0;
            extensionSendInterval = 10;
            initialHeaderBurst = 5;
            trailingHeaderBurst = 5;
            startTxNotifications = 5;
            customRtpPayloadType = -1;
            internalKey = 0;
            resetRtpOnTx = true;
            enableSmoothing = true;
            dtx = false;
            smoothedHangTimeMs = 0;
            hdrExtType = HeaderExtensionType_t::hetEngageStandard;
        }
    };
 
    static void to_json(nlohmann::json& j, const TxAudio& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(encoder),
            TOJSON_IMPL(encoderName),
            TOJSON_IMPL(framingMs),
            TOJSON_IMPL(blockCount),
            TOJSON_IMPL(fdx),
            TOJSON_IMPL(noHdrExt),
            TOJSON_IMPL(maxTxSecs),
            TOJSON_IMPL(extensionSendInterval),
            TOJSON_IMPL(initialHeaderBurst),
            TOJSON_IMPL(trailingHeaderBurst),
            TOJSON_IMPL(startTxNotifications),
            TOJSON_IMPL(customRtpPayloadType),
            TOJSON_IMPL(resetRtpOnTx),
            TOJSON_IMPL(enableSmoothing),
            TOJSON_IMPL(dtx),
            TOJSON_IMPL(smoothedHangTimeMs),
            TOJSON_IMPL(hdrExtType)
        };
 
        // internalKey is not serialized
    }
    static void from_json(const nlohmann::json& j, TxAudio& p)
    {
        p.clear();
        getOptional<bool>("enabled", p.enabled, j, true);        
        getOptional<TxAudio::TxCodec_t>("encoder", p.encoder, j, TxAudio::TxCodec_t::ctOpus8000);
        getOptional<std::string>("encoderName", p.encoderName, j, EMPTY_STRING);
        getOptional("framingMs", p.framingMs, j, 60);
        getOptional("blockCount", p.blockCount, j, 0);
        getOptional("fdx", p.fdx, j, false);
        getOptional("noHdrExt", p.noHdrExt, j, false);
        getOptional("maxTxSecs", p.maxTxSecs, j, 0);
        getOptional("extensionSendInterval", p.extensionSendInterval, j, 10);
        getOptional("initialHeaderBurst", p.initialHeaderBurst, j, 5);
        getOptional("trailingHeaderBurst", p.trailingHeaderBurst, j, 5);
        getOptional("startTxNotifications", p.startTxNotifications, j, 5);        
        getOptional("customRtpPayloadType", p.customRtpPayloadType, j, -1);
        getOptional("resetRtpOnTx", p.resetRtpOnTx, j, true);
        getOptional("enableSmoothing", p.enableSmoothing, j, true);
        getOptional("dtx", p.dtx, j, false);
        getOptional("smoothedHangTimeMs", p.smoothedHangTimeMs, j, 0);
        getOptional("hdrExtType", p.hdrExtType, j, TxAudio::HeaderExtensionType_t::hetEngageStandard);
 
        // internalKey is not serialized   
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(AudioRegistryDevice)
    class AudioRegistryDevice : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(AudioRegistryDevice)
 
    public:
        std::string     hardwareId;
 
        bool            isDefault;
 
        std::string     name;
 
        std::string     manufacturer;
 
        std::string     model;
 
        std::string     serialNumber;
 
 
        std::string     type;
 
        std::string     extra;
 
        AudioRegistryDevice()
        {
            clear();
        }
 
        void clear()
        {
            hardwareId.clear();
            isDefault = false;
            name.clear();
            manufacturer.clear();
            model.clear();
            serialNumber.clear();
            type.clear();
            extra.clear();
        }
 
        virtual std::string toString()
        {
            char buff[2048];
 
            snprintf(buff, sizeof(buff), "hardwareId=%s, isDefault=%d, name=%s, manufacturer=%s, model=%s, serialNumber=%s, type=%s, extra=%s",
                        hardwareId.c_str(),
                        (int)isDefault,
                        name.c_str(),
                        manufacturer.c_str(),
                        model.c_str(),
                        serialNumber.c_str(),
                        type.c_str(),
                        extra.c_str());
 
            return std::string(buff);
        }
    };
 
    static void to_json(nlohmann::json& j, const AudioRegistryDevice& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(hardwareId),
            TOJSON_IMPL(isDefault),
            TOJSON_IMPL(name),
            TOJSON_IMPL(manufacturer),
            TOJSON_IMPL(model),
            TOJSON_IMPL(serialNumber),
            TOJSON_IMPL(type),
            TOJSON_IMPL(extra)
        };
    }
    static void from_json(const nlohmann::json& j, AudioRegistryDevice& p)
    {
        p.clear();
        getOptional<std::string>("hardwareId", p.hardwareId, j, EMPTY_STRING);
        getOptional<bool>("isDefault", p.isDefault, j, false);
        getOptional("name", p.name, j);
        getOptional("manufacturer", p.manufacturer, j);
        getOptional("model", p.model, j);
        getOptional("serialNumber", p.serialNumber, j);
        getOptional("type", p.type, j);
        getOptional("extra", p.extra, j);
    }    
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(AudioRegistry)
    class AudioRegistry : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(AudioRegistry)
 
    public:
        std::vector<AudioRegistryDevice> inputs;
 
        std::vector<AudioRegistryDevice> outputs;
 
        AudioRegistry()
        {
            clear();
        }
 
        void clear()
        {
            inputs.clear();
            outputs.clear();
        }
 
        virtual std::string toString()
        {
            return std::string("");
        }
    };
 
    static void to_json(nlohmann::json& j, const AudioRegistry& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(inputs),
            TOJSON_IMPL(outputs)
        };
    }
    static void from_json(const nlohmann::json& j, AudioRegistry& p)
    {
        p.clear();
        getOptional<std::vector<AudioRegistryDevice>>("inputs", p.inputs, j);
        getOptional<std::vector<AudioRegistryDevice>>("outputs", p.outputs, j);
    } 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(AudioDeviceDescriptor)
    class AudioDeviceDescriptor : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(AudioDeviceDescriptor)
 
    public:
 
        typedef enum
        {
            dirUnknown = 0,
 
            dirInput,
 
            dirOutput,
 
            dirBoth
        } Direction_t;
 
        int             deviceId;
 
        int             samplingRate;
 
        int             channels;
 
        Direction_t     direction;
 
        int             boostPercentage;
 
        bool            isAdad;
 
        std::string     name;
 
        std::string     manufacturer;
 
        std::string     model;
 
        std::string     hardwareId;
 
        std::string     serialNumber;
 
        bool            isDefault;
 
        std::string     type;
 
        std::string     extra;
 
        bool            isPresent;
 
        AudioDeviceDescriptor()
        {
            clear();
        }
 
        void clear()
        {
            deviceId = 0;
            samplingRate = 0;
            channels = 0;
            direction = dirUnknown;
            boostPercentage = 0;
            isAdad = false;
            isDefault = false;
 
            name.clear();
            manufacturer.clear();
            model.clear();
            hardwareId.clear();
            serialNumber.clear();
            type.clear();
            extra.clear();
            isPresent = false;
        }
 
        virtual std::string toString()
        {
            char buff[2048];
 
            snprintf(buff, sizeof(buff), "deviceId=%d, samplingRate=%d, channels=%d, direction=%d, boostPercentage=%d, isAdad=%d, name=%s, manufacturer=%s, model=%s, hardwareId=%s, serialNumber=%s, isDefault=%d, type=%s, present=%d, extra=%s",
                        deviceId,
                        samplingRate,
                        channels,
                        (int)direction,
                        boostPercentage,
                        (int)isAdad,
                        name.c_str(),
                        manufacturer.c_str(),
                        model.c_str(),
                        hardwareId.c_str(),
                        serialNumber.c_str(),
                        (int)isDefault,
                        type.c_str(),
                        (int)isPresent,
                        extra.c_str());
 
            return std::string(buff);
        }
    };
 
    static void to_json(nlohmann::json& j, const AudioDeviceDescriptor& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(deviceId),
            TOJSON_IMPL(samplingRate),
            TOJSON_IMPL(channels),
            TOJSON_IMPL(direction),
            TOJSON_IMPL(boostPercentage),
            TOJSON_IMPL(isAdad),
            TOJSON_IMPL(name),
            TOJSON_IMPL(manufacturer),
            TOJSON_IMPL(model),
            TOJSON_IMPL(hardwareId),
            TOJSON_IMPL(serialNumber),
            TOJSON_IMPL(isDefault),
            TOJSON_IMPL(type),
            TOJSON_IMPL(extra),
            TOJSON_IMPL(isPresent)
        };
    }
    static void from_json(const nlohmann::json& j, AudioDeviceDescriptor& p)
    {
        p.clear();
        getOptional<int>("deviceId", p.deviceId, j, 0);
        getOptional<int>("samplingRate", p.samplingRate, j, 0);
        getOptional<int>("channels", p.channels, j, 0);
        getOptional<AudioDeviceDescriptor::Direction_t>("direction", p.direction, j,
                        AudioDeviceDescriptor::Direction_t::dirUnknown);
        getOptional<int>("boostPercentage", p.boostPercentage, j, 0);
 
        getOptional<bool>("isAdad", p.isAdad, j, false);
        getOptional("name", p.name, j);
        getOptional("manufacturer", p.manufacturer, j);
        getOptional("model", p.model, j);
        getOptional("hardwareId", p.hardwareId, j);
        getOptional("serialNumber", p.serialNumber, j);
        getOptional("isDefault", p.isDefault, j);
        getOptional("type", p.type, j);
        getOptional("extra", p.extra, j);
        getOptional<bool>("isPresent", p.isPresent, j, false);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(ListOfAudioDeviceDescriptor)
    class ListOfAudioDeviceDescriptor : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(ListOfAudioDeviceDescriptor)
 
    public:
        std::vector<AudioDeviceDescriptor> list;
 
        ListOfAudioDeviceDescriptor()
        {
            clear();
        }
 
        void clear()
        {
            list.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const ListOfAudioDeviceDescriptor& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(list)
        };
    }
    static void from_json(const nlohmann::json& j, ListOfAudioDeviceDescriptor& p)
    {
        p.clear();
        getOptional<std::vector<AudioDeviceDescriptor>>("list", p.list, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(Audio)
    class Audio : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(Audio)
 
    public:
        bool    enabled;
 
        int     inputId;
 
        std::string     inputHardwareId;
 
        int     inputGain;
 
        int     outputId;
 
        std::string     outputHardwareId;
 
        int     outputGain;
 
        int     outputLevelLeft;
 
        int     outputLevelRight;
 
        bool    outputMuted;
 
        Audio()
        {
            clear();
        }
 
        void clear()
        {
            enabled = true;
            inputId = 0;
            inputHardwareId.clear();
            inputGain = 0;
            outputId = 0;
            outputHardwareId.clear();
            outputGain = 0;
            outputLevelLeft = 100;
            outputLevelRight = 100;
            outputMuted = false;
        }
    };
 
    static void to_json(nlohmann::json& j, const Audio& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(inputId),
            TOJSON_IMPL(inputHardwareId),
            TOJSON_IMPL(inputGain),
            TOJSON_IMPL(outputId),
            TOJSON_IMPL(outputHardwareId),
            TOJSON_IMPL(outputLevelLeft),
            TOJSON_IMPL(outputLevelRight),
            TOJSON_IMPL(outputMuted)
        };
    }
    static void from_json(const nlohmann::json& j, Audio& p)
    {
        p.clear();
        getOptional<bool>("enabled", p.enabled, j, true);
        getOptional<int>("inputId", p.inputId, j, 0);
        getOptional<std::string>("inputHardwareId", p.inputHardwareId, j, EMPTY_STRING);
        getOptional<int>("inputGain", p.inputGain, j, 0);
        getOptional<int>("outputId", p.outputId, j, 0);
        getOptional<std::string>("outputHardwareId", p.outputHardwareId, j, EMPTY_STRING);
        getOptional<int>("outputGain", p.outputGain, j, 0);
        getOptional<int>("outputLevelLeft", p.outputLevelLeft, j, 100);
        getOptional<int>("outputLevelRight", p.outputLevelRight, j, 100);
        getOptional<bool>("outputMuted", p.outputMuted, j, false);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(TalkerInformation)
    class TalkerInformation : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(TalkerInformation)
 
    public:
        typedef enum
        {
            matNone                    = 0,
 
            matAnonymous                  = 1,
 
            matSsrcGenerated                 = 2
        } ManufacturedAliasType_t;
 
        std::string alias;
 
        std::string nodeId;
 
        uint16_t    rxFlags;
 
        int         txPriority;
 
        uint32_t    txId;
 
        int         duplicateCount;
 
        uint16_t    aliasSpecializer;
 
        bool        rxMuted;
 
        uint32_t     ssrc;
 
        ManufacturedAliasType_t     manufacturedAliasType;
 
        TalkerInformation()
        {
            clear();
        }
 
        void clear()
        {
            alias.clear();
            nodeId.clear();
            rxFlags = 0;
            txPriority = 0;
            txId = 0;
            duplicateCount = 0;
            aliasSpecializer = 0;
            rxMuted = false;
            manufacturedAliasType = ManufacturedAliasType_t::matNone;
            ssrc = 0;
        }
    };
 
    static void to_json(nlohmann::json& j, const TalkerInformation& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(alias),
            TOJSON_IMPL(nodeId),
            TOJSON_IMPL(rxFlags),
            TOJSON_IMPL(txPriority),
            TOJSON_IMPL(txId),
            TOJSON_IMPL(duplicateCount),
            TOJSON_IMPL(aliasSpecializer),
            TOJSON_IMPL(rxMuted),
            TOJSON_IMPL(manufacturedAliasType),
            TOJSON_IMPL(ssrc)
        };
    }
    static void from_json(const nlohmann::json& j, TalkerInformation& p)
    {
        p.clear();
        getOptional<std::string>("alias", p.alias, j, EMPTY_STRING);
        getOptional<std::string>("nodeId", p.nodeId, j, EMPTY_STRING);
        getOptional<uint16_t>("rxFlags", p.rxFlags, j, 0);
        getOptional<int>("txPriority", p.txPriority, j, 0);
        getOptional<uint32_t>("txId", p.txId, j, 0);
        getOptional<int>("duplicateCount", p.duplicateCount, j, 0);
        getOptional<uint16_t>("aliasSpecializer", p.aliasSpecializer, j, 0);
        getOptional<bool>("rxMuted", p.rxMuted, j, false);
        getOptional<TalkerInformation::ManufacturedAliasType_t>("manufacturedAliasType", p.manufacturedAliasType, j, TalkerInformation::ManufacturedAliasType_t::matNone);
        getOptional<uint32_t>("ssrc", p.ssrc, j, 0);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(GroupTalkers)
    class GroupTalkers : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(GroupTalkers)
 
    public:
        std::vector<TalkerInformation> list;
 
        GroupTalkers()
        {
            clear();
        }
 
        void clear()
        {
            list.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const GroupTalkers& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(list)
        };
    }
    static void from_json(const nlohmann::json& j, GroupTalkers& p)
    {
        p.clear();
        getOptional<std::vector<TalkerInformation>>("list", p.list, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(Presence)
    class Presence : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(Presence)
 
    public:
        typedef enum
        {
            pfUnknown       = 0,
 
            pfEngage        = 1,
 
            pfCot           = 2
        } Format_t;
 
        Format_t        format;
 
        int             intervalSecs;
 
        bool            listenOnly;
 
        int             minIntervalSecs;
 
        bool            reduceImmediacy;
 
        Presence()
        {
            clear();
        }
 
        void clear()
        {
            format = pfUnknown;
            intervalSecs = 30;
            listenOnly = false;
            minIntervalSecs = 5;
            reduceImmediacy = false;
        }
    };
 
    static void to_json(nlohmann::json& j, const Presence& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(format),
            TOJSON_IMPL(intervalSecs),
            TOJSON_IMPL(listenOnly),
            TOJSON_IMPL(minIntervalSecs),
            TOJSON_IMPL(reduceImmediacy)
        };
    }
    static void from_json(const nlohmann::json& j, Presence& p)
    {
        p.clear();
        getOptional<Presence::Format_t>("format", p.format, j, Presence::Format_t::pfEngage);
        getOptional<int>("intervalSecs", p.intervalSecs, j, 30);
        getOptional<bool>("listenOnly", p.listenOnly, j, false);
        getOptional<int>("minIntervalSecs", p.minIntervalSecs, j, 5);
        getOptional<bool>("reduceImmediacy", p.reduceImmediacy, j, false);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(Advertising)
    class Advertising : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(Advertising)
 
    public:
        bool        enabled;
 
        int         intervalMs;
 
        bool        alwaysAdvertise;
 
        Advertising()
        {
            clear();
        }
 
        void clear()
        {
            enabled = false;
            intervalMs = 20000;
            alwaysAdvertise = false;
        }
    };
 
    static void to_json(nlohmann::json& j, const Advertising& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(intervalMs),
            TOJSON_IMPL(alwaysAdvertise)
        };
    }
    static void from_json(const nlohmann::json& j, Advertising& p)
    {
        p.clear();
        getOptional("enabled", p.enabled, j, false);
        getOptional<int>("intervalMs", p.intervalMs, j, 20000);
        getOptional<bool>("alwaysAdvertise", p.alwaysAdvertise, j, false);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(GroupPriorityTranslation)
    class GroupPriorityTranslation : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(GroupPriorityTranslation)
 
    public:
        NetworkAddress          rx;
 
        NetworkAddress          tx;
 
        int                     priority;
 
        GroupPriorityTranslation()
        {
            clear();
        }
 
        void clear()
        {
            rx.clear();
            tx.clear();
            priority = 0;
        }
    };
 
    static void to_json(nlohmann::json& j, const GroupPriorityTranslation& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(rx),
            TOJSON_IMPL(tx),
            TOJSON_IMPL(priority)
        };
    }
    static void from_json(const nlohmann::json& j, GroupPriorityTranslation& p)
    {
        p.clear();
        j.at("rx").get_to(p.rx);
        j.at("tx").get_to(p.tx);
        FROMJSON_IMPL(priority, int, 0);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(GroupTimeline)
    class GroupTimeline : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(GroupTimeline)
 
    public:
        bool        enabled;
 
        int         maxAudioTimeMs;
        bool        recordAudio;
 
        GroupTimeline()
        {
            clear();
        }
 
        void clear()
        {
            enabled = true;
            maxAudioTimeMs = 30000;
            recordAudio = true;
        }
    };
 
    static void to_json(nlohmann::json& j, const GroupTimeline& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(maxAudioTimeMs),
            TOJSON_IMPL(recordAudio)
        };
    }
    static void from_json(const nlohmann::json& j, GroupTimeline& p)
    {
        p.clear();
        getOptional("enabled", p.enabled, j, true);
        getOptional<int>("maxAudioTimeMs", p.maxAudioTimeMs, j, 30000);
        getOptional("recordAudio", p.recordAudio, j, true);
    }
 
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_SOURCE_ENGAGE_INTERNAL = "com.rallytac.engage.internal";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_SOURCE_ENGAGE_MAGELLAN_CORE = "com.rallytac.magellan.core";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_SOURCE_ENGAGE_MAGELLAN_CISTECH = "com.rallytac.engage.magellan.cistech";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_SOURCE_ENGAGE_MAGELLAN_TRELLISWARE = "com.rallytac.engage.magellan.trellisware";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_SOURCE_ENGAGE_MAGELLAN_SILVUS = "com.rallytac.engage.magellan.silvus";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_SOURCE_ENGAGE_MAGELLAN_PERSISTENT = "com.rallytac.engage.magellan.persistent";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_SOURCE_ENGAGE_MAGELLAN_DOMO = "com.rallytac.engage.magellan.domo";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_SOURCE_ENGAGE_MAGELLAN_KENWOOD = "com.rallytac.engage.magellan.kenwood";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_SOURCE_ENGAGE_MAGELLAN_TAIT = "com.rallytac.engage.magellan.tait";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_SOURCE_ENGAGE_MAGELLAN_VOCALITY = "com.rallytac.engage.magellan.vocality";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NO_REAON = "NoReason";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NO_LINK = "NoLink";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_UNREGISTERED = "Unregistered";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NOT_ALLOWED = "NotAllowed";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_SECURITY_CLASSIFICATION_LEVEL_TOO_HIGH = "SecurityClassificationLevelTooHigh";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_GENERAL_DENIAL = "GeneralDenial";
 
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NO_ACCESS_TAG = "NoAccessTag";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_EXCLUDED_ACCESS_TAG = "ExcludedAccessTag";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NO_SERIAL = "NoSerial";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_EXCLUDED_SERIAL = "ExcludedSerial";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NO_FINGERPRINT = "NoFingerprint";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_EXCLUDED_FINGERPRINT = "ExcludedFingerprint";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NO_SUBJECT = "NoSubject";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_EXCLUDED_SUBJECT = "ExcludedSubject";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NO_ISSUER = "NoIssuer";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_EXCLUDED_ISSUER = "ExcludedIssuer";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_NOT_ON_WHITELIST = "NotOnWhitelist";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *GROUP_DISCONNECTED_REASON_ON_BLACKLIST = "OnBlacklist";
 
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *OID_RTS_PEM = "58217";
    ENGAGE_IGNORE_COMPILER_UNUSED_WARNING static const char *OID_RTS_CERT_SUBJ_ACCESS_TAGS = "1.3.6.1.4.1.58217.1";    
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(GroupAppTransport)
    class GroupAppTransport : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(GroupAppTransport)
 
    public:
        bool                        enabled;
 
        std::string                 id;
 
        GroupAppTransport()
        {
            clear();
        }
 
        void clear()
        {
            enabled = false;
            id.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const GroupAppTransport& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(id)
        };
    }
    static void from_json(const nlohmann::json& j, GroupAppTransport& p)
    {
        p.clear();
        getOptional<bool>("enabled", p.enabled, j, false);
        getOptional<std::string>("id", p.id, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RtpProfile)
    class RtpProfile : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RtpProfile)
 
    public:
        typedef enum
        {
            jmStandard        = 0,
 
            jmLowLatency      = 1,
 
            jmReleaseOnTxEnd   = 2
        } JitterMode_t;
 
        JitterMode_t                        mode;
 
        int                                 jitterMaxMs;
 
        int                                 jitterMinMs;
 
        int                                 jitterMaxFactor;
 
        int                                 latePacketSequenceRange;
 
        int                                 latePacketTimestampRangeMs;
 
        int                                 jitterTrimPercentage;
 
        int                                 jitterUnderrunReductionThresholdMs;
 
        int                                 jitterUnderrunReductionAger;
 
        int                                 jitterForceTrimAtMs;
 
        int                                 jitterMaxTrimMs;
 
        int                                 jitterMaxExceededClipPerc;
 
        int                                 jitterMaxExceededClipHangMs;
 
        int                                 inboundProcessorInactivityMs;
 
        int                                 rtcpPresenceTimeoutMs;
 
        int                                 zombieLifetimeMs;
 
        int                                 signalledInboundProcessorInactivityMs;
        
        RtpProfile()
        {
            clear();
        }
 
        void clear()
        {
            mode = jmStandard;
            jitterMaxMs = 10000;
            jitterMinMs = 100;
            jitterMaxFactor = 8;
            jitterTrimPercentage = 10;
            jitterUnderrunReductionThresholdMs = 1500;
            jitterUnderrunReductionAger = 100;
            latePacketSequenceRange = 5;
            latePacketTimestampRangeMs = 2000;
            inboundProcessorInactivityMs = 500;
            jitterForceTrimAtMs = 0;
            rtcpPresenceTimeoutMs = 45000;
            jitterMaxExceededClipPerc = 10;
            jitterMaxExceededClipHangMs = 1500;
            zombieLifetimeMs = 15000;
            jitterMaxTrimMs = 250;
            signalledInboundProcessorInactivityMs = (inboundProcessorInactivityMs * 4);
        }
    };
 
    static void to_json(nlohmann::json& j, const RtpProfile& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(mode),
            TOJSON_IMPL(jitterMaxMs),
            TOJSON_IMPL(inboundProcessorInactivityMs),
            TOJSON_IMPL(jitterMinMs),
            TOJSON_IMPL(jitterMaxFactor),
            TOJSON_IMPL(jitterTrimPercentage),
            TOJSON_IMPL(jitterUnderrunReductionThresholdMs),
            TOJSON_IMPL(jitterUnderrunReductionAger),
            TOJSON_IMPL(latePacketSequenceRange),
            TOJSON_IMPL(latePacketTimestampRangeMs),
            TOJSON_IMPL(inboundProcessorInactivityMs),
            TOJSON_IMPL(jitterForceTrimAtMs),
            TOJSON_IMPL(jitterMaxExceededClipPerc),
            TOJSON_IMPL(jitterMaxExceededClipHangMs),
            TOJSON_IMPL(zombieLifetimeMs),
            TOJSON_IMPL(jitterMaxTrimMs),
            TOJSON_IMPL(signalledInboundProcessorInactivityMs)
        };
    }
    static void from_json(const nlohmann::json& j, RtpProfile& p)
    {
        p.clear();
        FROMJSON_IMPL(mode, RtpProfile::JitterMode_t, RtpProfile::JitterMode_t::jmStandard);
        FROMJSON_IMPL(jitterMaxMs, int, 10000);
        FROMJSON_IMPL(jitterMinMs, int, 20);
        FROMJSON_IMPL(jitterMaxFactor, int, 8);
        FROMJSON_IMPL(jitterTrimPercentage, int, 10);
        FROMJSON_IMPL(jitterUnderrunReductionThresholdMs, int, 1500);
        FROMJSON_IMPL(jitterUnderrunReductionAger, int, 100);        
        FROMJSON_IMPL(latePacketSequenceRange, int, 5);
        FROMJSON_IMPL(latePacketTimestampRangeMs, int, 2000);
        FROMJSON_IMPL(inboundProcessorInactivityMs, int, 500);
        FROMJSON_IMPL(jitterForceTrimAtMs, int, 0);        
        FROMJSON_IMPL(rtcpPresenceTimeoutMs, int, 45000);
        FROMJSON_IMPL(jitterMaxExceededClipPerc, int, 10);
        FROMJSON_IMPL(jitterMaxExceededClipHangMs, int, 1500);
        FROMJSON_IMPL(zombieLifetimeMs, int, 15000);
        FROMJSON_IMPL(jitterMaxTrimMs, int, 250);
        FROMJSON_IMPL(signalledInboundProcessorInactivityMs, int, (p.inboundProcessorInactivityMs * 4));
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(Tls)
    class Tls : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(Tls)
 
    public:
 
        bool                        verifyPeers;
 
        bool                        allowSelfSignedCertificates;
 
        std::vector<std::string>    caCertificates;
 
        StringRestrictionList       subjectRestrictions;
 
        StringRestrictionList       issuerRestrictions;
 
        std::vector<std::string>    crlSerials;
 
        Tls()
        {
            clear();
        }
 
        void clear()
        {
            verifyPeers = true;
            allowSelfSignedCertificates = false;
            caCertificates.clear();
            subjectRestrictions.clear();
            issuerRestrictions.clear();
            crlSerials.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const Tls& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(verifyPeers),
            TOJSON_IMPL(allowSelfSignedCertificates),
            TOJSON_IMPL(caCertificates),
            TOJSON_IMPL(subjectRestrictions),
            TOJSON_IMPL(issuerRestrictions),
            TOJSON_IMPL(crlSerials)
        };
    }
    static void from_json(const nlohmann::json& j, Tls& p)
    {
        p.clear();
        getOptional<bool>("verifyPeers", p.verifyPeers, j, true);
        getOptional<bool>("allowSelfSignedCertificates", p.allowSelfSignedCertificates, j, false);
        getOptional<std::vector<std::string>>("caCertificates", p.caCertificates, j);
        getOptional<StringRestrictionList>("subjectRestrictions", p.subjectRestrictions, j);
        getOptional<StringRestrictionList>("issuerRestrictions", p.issuerRestrictions, j);
        getOptional<std::vector<std::string>>("crlSerials", p.crlSerials, j);
    }
    
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RangerPackets)
    class RangerPackets : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RangerPackets)
 
    public:
        int             hangTimerSecs;
 
        int             count;
 
        RangerPackets()
        {
            clear();
        }
 
        void clear()
        {
            hangTimerSecs = -1;
            count = 5;
        }
 
        virtual void initForDocumenting()
        {
        }
    };
 
    static void to_json(nlohmann::json& j, const RangerPackets& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(hangTimerSecs),
            TOJSON_IMPL(count)
        };
    }
    static void from_json(const nlohmann::json& j, RangerPackets& p)
    {
        p.clear();
        getOptional<int>("hangTimerSecs", p.hangTimerSecs, j, 11);
        getOptional<int>("count", p.count, j, 5);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(Source)
    class Source : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(Source)
 
    public:
        std::string             nodeId;
 
        /* NOTE: Not serialized ! */
        uint8_t                 _internal_binary_nodeId[ENGAGE_MAX_NODE_ID_SIZE];
 
        std::string             alias;
        
        /* NOTE: Not serialized ! */
        uint8_t                 _internal_binary_alias[ENGAGE_MAX_ALIAS_SIZE];
 
        Source()
        {
            clear();
        }
 
        void clear()
        {
            nodeId.clear();
            memset(_internal_binary_nodeId, 0, sizeof(_internal_binary_nodeId));
            
            alias.clear();
            memset(_internal_binary_alias, 0, sizeof(_internal_binary_alias));
        }
 
        virtual void initForDocumenting()
        {
        }
    };
 
    static void to_json(nlohmann::json& j, const Source& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(nodeId),
            TOJSON_IMPL(alias)
        };
    }
    static void from_json(const nlohmann::json& j, Source& p)
    {
        p.clear();
        FROMJSON_IMPL_SIMPLE(nodeId);
        FROMJSON_IMPL_SIMPLE(alias);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(GroupBridgeTargetOutputDetail)
    class GroupBridgeTargetOutputDetail : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(GroupBridgeTargetOutputDetail)
 
    public:
        typedef enum
        {
            bomRaw                      = 0,
 
            bomMultistream              = 1,
 
            bomMixedStream              = 2,
 
            bomNone                     = 3
        } BridgingOpMode_t;
 
        BridgingOpMode_t        mode;
 
        AdvancedTxParams        mixedStreamTxParams;
 
        GroupBridgeTargetOutputDetail()
        {
            clear();
        }
 
        void clear()
        {
            mode = BridgingOpMode_t::bomRaw;
            mixedStreamTxParams.clear();
        }
 
        virtual void initForDocumenting()
        {
            clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const GroupBridgeTargetOutputDetail& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(mode),
            TOJSON_IMPL(mixedStreamTxParams)
        };
    }
    static void from_json(const nlohmann::json& j, GroupBridgeTargetOutputDetail& p)
    {
        p.clear();
        FROMJSON_IMPL_SIMPLE(mode);
        FROMJSON_IMPL_SIMPLE(mixedStreamTxParams);
    }    
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(GroupDefaultAudioPriority)
    class GroupDefaultAudioPriority : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(GroupDefaultAudioPriority)
 
    public:
        uint8_t        tx;
 
        uint8_t        rx;
 
        GroupDefaultAudioPriority()
        {
            clear();
        }
 
        void clear()
        {
            tx = 0;
            rx = 0;
        }
 
        virtual void initForDocumenting()
        {
            clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const GroupDefaultAudioPriority& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(tx),
            TOJSON_IMPL(rx)
        };
    }
    static void from_json(const nlohmann::json& j, GroupDefaultAudioPriority& p)
    {
        p.clear();
        FROMJSON_IMPL_SIMPLE(tx);
        FROMJSON_IMPL_SIMPLE(rx);
    }  
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(Group)
    class Group : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(Group)
 
    public:
        typedef enum
        {
            gtUnknown   = 0,
 
            gtAudio     = 1,
 
            gtPresence  = 2,
 
            gtRaw       = 3
        } Type_t;
 
        typedef enum
        {
            iagpAnonymousAlias          = 0,
 
            iagpSsrcInHex               = 1
        } InboundAliasGenerationPolicy_t;
 
        Type_t                                  type;
 
        GroupBridgeTargetOutputDetail          bridgeTargetOutputDetail;
 
        GroupDefaultAudioPriority               defaultAudioPriority;
 
        std::string                             id;
 
        std::string                             name;
 
        std::string                             spokenName;
 
        std::string                             interfaceName;
 
        NetworkAddress                          rx;
 
        NetworkAddress                          tx;
 
        NetworkTxOptions                        txOptions;
 
        TxAudio                                 txAudio;
 
        Presence                                presence;
 
        std::string                             cryptoPassword;
 
        bool                                    lbCrypto;
 
        std::vector<Rallypoint>                 rallypoints;
 
        RallypointCluster                       rallypointCluster;
 
        Audio                                   audio;
 
        GroupTimeline                           timeline;
 
        std::string                             alias;
 
        bool                                    blockAdvertising;
 
        std::string                             source;
 
        int                                     maxRxSecs;
 
        bool                                    enableMulticastFailover;
 
        int                                     multicastFailoverSecs;
 
        NetworkAddress                          rtcpPresenceRx;
 
        std::vector<std::string>                presenceGroupAffinities;
 
        bool                                    disablePacketEvents;
 
        int                                     rfc4733RtpPayloadId;
 
        std::vector<RtpPayloadTypeTranslation>  inboundRtpPayloadTypeTranslations;
 
        GroupPriorityTranslation                priorityTranslation;
 
        int                                     stickyTidHangSecs;
 
        std::string                             anonymousAlias;
 
        GroupAppTransport                       appTransport;
 
        bool                                    allowLoopback;
 
        RtpProfile                              rtpProfile;
 
        RangerPackets                           rangerPackets;
        
        bool                                    _wasDeserialized_rtpProfile;
 
        TransportImpairment                     txImpairment;
 
        TransportImpairment                     rxImpairment;
 
        std::vector<uint16_t>                   specializerAffinities;
 
        uint32_t                                securityLevel;
 
        std::vector<Source>                     ignoreSources;
 
        std::string                             languageCode;
 
        std::string                             synVoice;
 
        PacketCapturer                          rxCapture;
 
        PacketCapturer                          txCapture;
 
        uint16_t                                blobRtpPayloadType;
 
        InboundAliasGenerationPolicy_t          inboundAliasGenerationPolicy;
 
        AudioGate                               gateIn;
 
        bool                                    ignoreAudioTraffic;
 
        Group()
        {
            clear();
        }
 
        void clear()
        {
            type = gtUnknown;
            bridgeTargetOutputDetail.clear();
            defaultAudioPriority.clear();
            id.clear();
            name.clear();
            spokenName.clear();
            interfaceName.clear();
            rx.clear();
            tx.clear();
            txOptions.clear();
            txAudio.clear();
            presence.clear();
            cryptoPassword.clear();
 
            alias.clear();
 
            rallypoints.clear();
            rallypointCluster.clear();
 
            audio.clear();
            timeline.clear();
 
            blockAdvertising = false;
 
            source.clear();
 
            maxRxSecs = 0;
 
            enableMulticastFailover = false;
            multicastFailoverSecs = 10;
 
            rtcpPresenceRx.clear();
 
            presenceGroupAffinities.clear();
            disablePacketEvents = false;
 
            rfc4733RtpPayloadId = 0;
            inboundRtpPayloadTypeTranslations.clear();
            priorityTranslation.clear();
 
            stickyTidHangSecs = 10;
            anonymousAlias.clear();
            lbCrypto = false;
 
            appTransport.clear();
            allowLoopback = false;
 
            rtpProfile.clear();
            rangerPackets.clear();
 
            _wasDeserialized_rtpProfile = false;
 
            txImpairment.clear();
            rxImpairment.clear();
 
            specializerAffinities.clear();
 
            securityLevel = 0;
 
            ignoreSources.clear();
 
            languageCode.clear();
            synVoice.clear();
 
            rxCapture.clear();
            txCapture.clear();
 
            blobRtpPayloadType = ENGAGE_DEFAULT_BLOB_RTP_PAYLOAD_TYPE;
            inboundAliasGenerationPolicy = iagpAnonymousAlias;
            gateIn.clear();
 
            ignoreAudioTraffic = false;
        }
    };
 
    static void to_json(nlohmann::json& j, const Group& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(type),
            TOJSON_IMPL(bridgeTargetOutputDetail),
            TOJSON_IMPL(defaultAudioPriority),
            TOJSON_IMPL(id),
            TOJSON_IMPL(name),
            TOJSON_IMPL(spokenName),
            TOJSON_IMPL(interfaceName),
            TOJSON_IMPL(rx),
            TOJSON_IMPL(tx),
            TOJSON_IMPL(txOptions),
            TOJSON_IMPL(txAudio),
            TOJSON_IMPL(presence),
            TOJSON_IMPL(cryptoPassword),
            TOJSON_IMPL(alias),
 
            // See below
            //TOJSON_IMPL(rallypoints),
            //TOJSON_IMPL(rallypointCluster),
 
            TOJSON_IMPL(alias),
            TOJSON_IMPL(audio),
            TOJSON_IMPL(timeline),
            TOJSON_IMPL(blockAdvertising),
            TOJSON_IMPL(source),
            TOJSON_IMPL(maxRxSecs),
            TOJSON_IMPL(enableMulticastFailover),
            TOJSON_IMPL(multicastFailoverSecs),
            TOJSON_IMPL(rtcpPresenceRx),
            TOJSON_IMPL(presenceGroupAffinities),
            TOJSON_IMPL(disablePacketEvents),
            TOJSON_IMPL(rfc4733RtpPayloadId),
            TOJSON_IMPL(inboundRtpPayloadTypeTranslations),
            TOJSON_IMPL(priorityTranslation),
            TOJSON_IMPL(stickyTidHangSecs),
            TOJSON_IMPL(anonymousAlias),
            TOJSON_IMPL(lbCrypto),
            TOJSON_IMPL(appTransport),
            TOJSON_IMPL(allowLoopback),
            TOJSON_IMPL(rangerPackets),
 
            TOJSON_IMPL(txImpairment),
            TOJSON_IMPL(rxImpairment),
 
            TOJSON_IMPL(specializerAffinities),
 
            TOJSON_IMPL(securityLevel),
 
            TOJSON_IMPL(ignoreSources),
 
            TOJSON_IMPL(languageCode),
            TOJSON_IMPL(synVoice),
 
            TOJSON_IMPL(rxCapture),
            TOJSON_IMPL(txCapture),
 
            TOJSON_IMPL(blobRtpPayloadType),
 
            TOJSON_IMPL(inboundAliasGenerationPolicy),
 
            TOJSON_IMPL(gateIn),
 
            TOJSON_IMPL(ignoreAudioTraffic)
        };
 
        TOJSON_BASE_IMPL();
 
        // TODO: need a better way to indicate whether rtpProfile is present
        if(p._wasDeserialized_rtpProfile || p.isDocumenting())
        {
            j["rtpProfile"] = p.rtpProfile;
        }
 
        if(p.isDocumenting())
        {
            j["rallypointCluster"] = p.rallypointCluster;
            j["rallypoints"] = p.rallypoints;
        }
        else
        {
            // rallypointCluster takes precedence if it has elements
            if(!p.rallypointCluster.rallypoints.empty())
            {
                j["rallypointCluster"] = p.rallypointCluster;
            }
            else if(!p.rallypoints.empty())
            {
                j["rallypoints"] = p.rallypoints;
            }
        }
    }
    static void from_json(const nlohmann::json& j, Group& p)
    {
        p.clear();
        j.at("type").get_to(p.type);
        getOptional<GroupBridgeTargetOutputDetail>("bridgeTargetOutputDetail", p.bridgeTargetOutputDetail, j);
        j.at("id").get_to(p.id);
        getOptional<std::string>("name", p.name, j);
        getOptional<std::string>("spokenName", p.spokenName, j);
        getOptional<std::string>("interfaceName", p.interfaceName, j);
        getOptional<NetworkAddress>("rx", p.rx, j);
        getOptional<NetworkAddress>("tx", p.tx, j);
        getOptional<NetworkTxOptions>("txOptions", p.txOptions, j);
        getOptional<std::string>("cryptoPassword", p.cryptoPassword, j);
        getOptional<std::string>("alias", p.alias, j);
        getOptional<TxAudio>("txAudio", p.txAudio, j);
        getOptional<Presence>("presence", p.presence, j);
        getOptional<std::vector<Rallypoint>>("rallypoints", p.rallypoints, j);
        getOptional<RallypointCluster>("rallypointCluster", p.rallypointCluster, j);        
        getOptional<Audio>("audio", p.audio, j);
        getOptional<GroupTimeline>("timeline", p.timeline, j);
        getOptional<bool>("blockAdvertising", p.blockAdvertising, j, false);
        getOptional<std::string>("source", p.source, j);
        getOptional<int>("maxRxSecs", p.maxRxSecs, j, 0);
        getOptional<bool>("enableMulticastFailover", p.enableMulticastFailover, j, false);
        getOptional<int>("multicastFailoverSecs", p.multicastFailoverSecs, j, 10);
        getOptional<NetworkAddress>("rtcpPresenceRx", p.rtcpPresenceRx, j);
        getOptional<std::vector<std::string>>("presenceGroupAffinities", p.presenceGroupAffinities, j);
        getOptional<bool>("disablePacketEvents", p.disablePacketEvents, j, false);
        getOptional<int>("rfc4733RtpPayloadId", p.rfc4733RtpPayloadId, j, 0);
        getOptional<std::vector<RtpPayloadTypeTranslation>>("inboundRtpPayloadTypeTranslations", p.inboundRtpPayloadTypeTranslations, j);
        getOptional<GroupPriorityTranslation>("priorityTranslation", p.priorityTranslation, j);
        getOptional<GroupDefaultAudioPriority>("defaultAudioPriority", p.defaultAudioPriority, j);
        getOptional<int>("stickyTidHangSecs", p.stickyTidHangSecs, j, 10);
        getOptional<std::string>("anonymousAlias", p.anonymousAlias, j);
        getOptional<bool>("lbCrypto", p.lbCrypto, j, false);
        getOptional<GroupAppTransport>("appTransport", p.appTransport, j);
        getOptional<bool>("allowLoopback", p.allowLoopback, j, false);
        getOptionalWithIndicator<RtpProfile>("rtpProfile", p.rtpProfile, j, &p._wasDeserialized_rtpProfile);
        getOptional<RangerPackets>("rangerPackets", p.rangerPackets, j);
        getOptional<TransportImpairment>("txImpairment", p.txImpairment, j);
        getOptional<TransportImpairment>("rxImpairment", p.rxImpairment, j);
        getOptional<std::vector<uint16_t>>("specializerAffinities", p.specializerAffinities, j);
        getOptional<uint32_t>("securityLevel", p.securityLevel, j, 0);
        getOptional<std::vector<Source>>("ignoreSources", p.ignoreSources, j);
        getOptional<std::string>("languageCode", p.languageCode, j);
        getOptional<std::string>("synVoice", p.synVoice, j);        
 
        getOptional<PacketCapturer>("rxCapture", p.rxCapture, j);
        getOptional<PacketCapturer>("txCapture", p.txCapture, j);
 
        getOptional<uint16_t>("blobRtpPayloadType", p.blobRtpPayloadType, j, ENGAGE_DEFAULT_BLOB_RTP_PAYLOAD_TYPE);
 
        getOptional<Group::InboundAliasGenerationPolicy_t>("inboundAliasGenerationPolicy", p.inboundAliasGenerationPolicy, j, Group::InboundAliasGenerationPolicy_t::iagpAnonymousAlias);
 
        getOptional<AudioGate>("gateIn", p.gateIn, j);
 
        getOptional<bool>("ignoreAudioTraffic", p.ignoreAudioTraffic, j, false);
        
        FROMJSON_BASE_IMPL();
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(Mission)
    class Mission : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(Mission)
 
    public:
        std::string                             id;
        std::string                             name;
        std::vector<Group>                      groups;
        std::chrono::system_clock::time_point   begins;
        std::chrono::system_clock::time_point   ends;
        std::string                             certStoreId;
        int                                     multicastFailoverPolicy;
        Rallypoint                              rallypoint;
 
        void clear()
        {
            id.clear();
            name.clear();
            groups.clear();
            certStoreId.clear();
            multicastFailoverPolicy = 0;
            rallypoint.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const Mission& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(name),
            TOJSON_IMPL(groups),
            TOJSON_IMPL(certStoreId),
            TOJSON_IMPL(multicastFailoverPolicy),
            TOJSON_IMPL(rallypoint)
        };
    }
 
    static void from_json(const nlohmann::json& j, Mission& p)
    {
        p.clear();
        j.at("id").get_to(p.id);
        j.at("name").get_to(p.name);
 
        // Groups are optional
        try
        {
            j.at("groups").get_to(p.groups);
        }
        catch(...)
        {
            p.groups.clear();
        }
 
        FROMJSON_IMPL(certStoreId, std::string, EMPTY_STRING);
        FROMJSON_IMPL(multicastFailoverPolicy, int, 0);
        getOptional<Rallypoint>("rallypoint", p.rallypoint, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(LicenseDescriptor)
    class LicenseDescriptor : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(LicenseDescriptor)
 
    public:
        static const int STATUS_OK = 0;
        static const int ERR_NULL_ENTITLEMENT_KEY = -1;
        static const int ERR_NULL_LICENSE_KEY = -2;
        static const int ERR_INVALID_LICENSE_KEY_LEN = -3;
        static const int ERR_LICENSE_KEY_VERIFICATION_FAILURE = -4;
        static const int ERR_ACTIVATION_CODE_VERIFICATION_FAILURE = -5;
        static const int ERR_INVALID_EXPIRATION_DATE = -6;
        static const int ERR_GENERAL_FAILURE = -7;
        static const int ERR_NOT_INITIALIZED = -8;
        static const int ERR_REQUIRES_ACTIVATION = -9;
        static const int ERR_LICENSE_NOT_SUITED_FOR_ACTIVATION = -10;
        static const uint8_t LIC_CARGO_FLAG_LIMIT_TO_FEATURES = 0x01;
        std::string                             entitlement;
 
        std::string                             key;
 
        std::string                             activationCode;
 
        std::string                             deviceId;
 
        int                                     type;
 
        time_t                                  expires;
 
        std::string                             expiresFormatted;
 
        uint32_t                                flags;
 
        std::string                             cargo;
 
        uint8_t                                 cargoFlags;
 
        int                                     status;
 
        std::string                             manufacturerId;
 
        std::string                             activationHmac;
 
        LicenseDescriptor()
        {
            clear();
        }
 
        void clear()
        {
            entitlement.clear();
            key.clear();
            activationCode.clear();
            type = 0;
            expires = 0;
            expiresFormatted.clear();
            flags = 0;
            cargo.clear();
            cargoFlags = 0;
            deviceId.clear();
            status = ERR_NOT_INITIALIZED;
            manufacturerId.clear();
            activationHmac.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const LicenseDescriptor& p)
    {
        j = nlohmann::json{
            //TOJSON_IMPL(entitlement),
            {"entitlement", "*entitlement*"},
            TOJSON_IMPL(key),
            TOJSON_IMPL(activationCode),
            TOJSON_IMPL(type),
            TOJSON_IMPL(expires),
            TOJSON_IMPL(expiresFormatted),
            TOJSON_IMPL(flags),
            TOJSON_IMPL(deviceId),
            TOJSON_IMPL(status),
            //TOJSON_IMPL(manufacturerId),
            {"manufacturerId", "*manufacturerId*"},
            TOJSON_IMPL(cargo),
            TOJSON_IMPL(cargoFlags),
            TOJSON_IMPL(activationHmac)
        };
    }
 
    static void from_json(const nlohmann::json& j, LicenseDescriptor& p)
    {
        p.clear();
        FROMJSON_IMPL(entitlement, std::string, EMPTY_STRING);
        FROMJSON_IMPL(key, std::string, EMPTY_STRING);
        FROMJSON_IMPL(activationCode, std::string, EMPTY_STRING);
        FROMJSON_IMPL(type, int, 0);
        FROMJSON_IMPL(expires, time_t, 0);
        FROMJSON_IMPL(expiresFormatted, std::string, EMPTY_STRING);
        FROMJSON_IMPL(flags, uint32_t, 0);
        FROMJSON_IMPL(deviceId, std::string, EMPTY_STRING);
        FROMJSON_IMPL(status, int, LicenseDescriptor::ERR_NOT_INITIALIZED);
        FROMJSON_IMPL(manufacturerId, std::string, EMPTY_STRING);
        FROMJSON_IMPL(cargo, std::string, EMPTY_STRING);
        FROMJSON_IMPL(cargoFlags, uint8_t, 0);
        FROMJSON_IMPL(activationHmac, std::string, EMPTY_STRING);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EngineNetworkingRpUdpStreaming)
    class EngineNetworkingRpUdpStreaming : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EngineNetworkingRpUdpStreaming)
 
    public:
        bool                                enabled;
 
        int                                 port;
 
        int                                 keepaliveIntervalSecs;
 
        TxPriority_t                        priority;
 
        int                                 ttl;
 
        EngineNetworkingRpUdpStreaming()
        {
            clear();
        }
 
        void clear()
        {
            enabled = false;
            port = 0;
            keepaliveIntervalSecs = 15;
            priority = TxPriority_t::priVoice;
            ttl = 64;
        }
 
        virtual void initForDocumenting()
        {
        }
    };
 
    static void to_json(nlohmann::json& j, const EngineNetworkingRpUdpStreaming& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(port),
            TOJSON_IMPL(keepaliveIntervalSecs),
            TOJSON_IMPL(priority),
            TOJSON_IMPL(ttl)
        };
    }
    static void from_json(const nlohmann::json& j, EngineNetworkingRpUdpStreaming& p)
    {
        p.clear();
        getOptional<bool>("enabled", p.enabled, j, false);
        getOptional<int>("port", p.port, j, 0);
        getOptional<int>("keepaliveIntervalSecs", p.keepaliveIntervalSecs, j, 15);
        getOptional<TxPriority_t>("priority", p.priority, j, TxPriority_t::priVoice);
        getOptional<int>("ttl", p.ttl, j, 64);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EnginePolicyNetworking)
    class EnginePolicyNetworking : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EnginePolicyNetworking)
 
    public:
        std::string                         defaultNic;
 
        int                                 multicastRejoinSecs;
 
        int                                 rallypointRtTestIntervalMs;
 
        bool                                logRtpJitterBufferStats;
 
        bool                                preventMulticastFailover;        
 
        EngineNetworkingRpUdpStreaming      rpUdpStreaming;
 
        RtpProfile                          rtpProfile;
 
        AddressResolutionPolicy_t         addressResolutionPolicy;
 
        EnginePolicyNetworking()
        {
            clear();
        }
 
        void clear()
        {
            defaultNic.clear();
            multicastRejoinSecs = 8;
            rallypointRtTestIntervalMs = 60000;
            logRtpJitterBufferStats = false;
            preventMulticastFailover = false;
            addressResolutionPolicy = AddressResolutionPolicy_t::arpIpv6ThenIpv4;
 
            rpUdpStreaming.clear();
            rtpProfile.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const EnginePolicyNetworking& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(defaultNic),
            TOJSON_IMPL(multicastRejoinSecs),
 
            TOJSON_IMPL(rallypointRtTestIntervalMs),
            TOJSON_IMPL(logRtpJitterBufferStats),
            TOJSON_IMPL(preventMulticastFailover),
 
            TOJSON_IMPL(rpUdpStreaming),
            TOJSON_IMPL(rtpProfile),
            TOJSON_IMPL(addressResolutionPolicy)
        };
    }
    static void from_json(const nlohmann::json& j, EnginePolicyNetworking& p)
    {
        p.clear();
        FROMJSON_IMPL(defaultNic, std::string, EMPTY_STRING);
        FROMJSON_IMPL(multicastRejoinSecs, int, 8);
        FROMJSON_IMPL(rallypointRtTestIntervalMs, int, 60000);
        FROMJSON_IMPL(logRtpJitterBufferStats, bool, false);
        FROMJSON_IMPL(preventMulticastFailover, bool, false);
 
        getOptional<EngineNetworkingRpUdpStreaming>("rpUdpStreaming", p.rpUdpStreaming, j);
        getOptional<RtpProfile>("rtpProfile", p.rtpProfile, j);
        getOptional<AddressResolutionPolicy_t>("addressResolutionPolicy", p.addressResolutionPolicy, j, AddressResolutionPolicy_t::arpIpv6ThenIpv4);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(Aec)
    class Aec : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(Aec)
 
    public:
        typedef enum
        {
            aecmDefault         = 0,
 
            aecmLow             = 1,
 
            aecmMedium          = 2,
 
            aecmHigh            = 3,
 
            aecmVeryHigh        = 4,
 
            aecmHighest         = 5
        } Mode_t;
 
        bool                enabled;
 
        Mode_t              mode;
 
        int                 speakerTailMs;
 
        bool                cng;
 
        Aec()
        {
            clear();
        }
 
        void clear()
        {
            enabled = false;
            mode = aecmDefault;
            speakerTailMs = 60;
            cng = true;
        }
    };
 
    static void to_json(nlohmann::json& j, const Aec& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(mode),
            TOJSON_IMPL(speakerTailMs),
            TOJSON_IMPL(cng)
        };
    }
    static void from_json(const nlohmann::json& j, Aec& p)
    {
        p.clear();
        FROMJSON_IMPL(enabled, bool, false);
        FROMJSON_IMPL(mode, Aec::Mode_t, Aec::Mode_t::aecmDefault);
        FROMJSON_IMPL(speakerTailMs, int, 60);
        FROMJSON_IMPL(cng, bool, true);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(Vad)
    class Vad : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(Vad)
 
    public:
        typedef enum
        {
            vamDefault          = 0,
 
            vamLowBitRate       = 1,
 
            vamAggressive       = 2,
 
            vamVeryAggressive   = 3
        } Mode_t;
 
        bool                enabled;
 
        Mode_t              mode;
 
        Vad()
        {
            clear();
        }
 
        void clear()
        {
            enabled = false;
            mode = vamDefault;
        }
    };
 
    static void to_json(nlohmann::json& j, const Vad& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(mode)
        };
    }
    static void from_json(const nlohmann::json& j, Vad& p)
    {
        p.clear();
        FROMJSON_IMPL(enabled, bool, false);
        FROMJSON_IMPL(mode, Vad::Mode_t, Vad::Mode_t::vamDefault);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(Bridge)
    class Bridge : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(Bridge)
 
    public:
        std::string                 id;
 
        std::string                 name;
 
        std::vector<std::string>    groups;
 
        bool                        enabled;
 
        Bridge()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            name.clear();
            groups.clear();
            enabled = true;
        }
    };
 
    static void to_json(nlohmann::json& j, const Bridge& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(name),
            TOJSON_IMPL(groups),
            TOJSON_IMPL(enabled)
        };
    }
    static void from_json(const nlohmann::json& j, Bridge& p)
    {
        p.clear();
        FROMJSON_IMPL(id, std::string, EMPTY_STRING);
        FROMJSON_IMPL(name, std::string, EMPTY_STRING);
        getOptional<std::vector<std::string>>("groups", p.groups, j);
        FROMJSON_IMPL(enabled, bool, true);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(AndroidAudio)
    class AndroidAudio : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(AndroidAudio)
 
    public:
        constexpr static int INVALID_SESSION_ID = -9999;
 
        int                 api;
 
        int                 sharingMode;
 
        int                 performanceMode;
 
        int                 usage;
 
        int                 contentType;
 
        int                 inputPreset;
 
        int                 sessionId;
 
        int                 engineMode;
 
 
        AndroidAudio()
        {
            clear();
        }
 
        void clear()
        {
            api = 0;
            sharingMode = 0;
            performanceMode = 12;
            usage = 2;
            contentType = 1;
            inputPreset = 7;
            sessionId = AndroidAudio::INVALID_SESSION_ID;
            engineMode = 0;
        }
    };
 
    static void to_json(nlohmann::json& j, const AndroidAudio& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(api),
            TOJSON_IMPL(sharingMode),
            TOJSON_IMPL(performanceMode),
            TOJSON_IMPL(usage),
            TOJSON_IMPL(contentType),
            TOJSON_IMPL(inputPreset),
            TOJSON_IMPL(sessionId),
            TOJSON_IMPL(engineMode)
        };
    }
    static void from_json(const nlohmann::json& j, AndroidAudio& p)
    {
        p.clear();
        FROMJSON_IMPL(api, int, 0);
        FROMJSON_IMPL(sharingMode, int, 0);
        FROMJSON_IMPL(performanceMode, int, 12);
        FROMJSON_IMPL(usage, int, 2);
        FROMJSON_IMPL(contentType, int, 1);
        FROMJSON_IMPL(inputPreset, int, 7);
        FROMJSON_IMPL(sessionId, int, AndroidAudio::INVALID_SESSION_ID);
        FROMJSON_IMPL(engineMode, int, 0);
    }    
    
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EnginePolicyAudio)
    class EnginePolicyAudio : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EnginePolicyAudio)
 
    public:
        bool                enabled;
 
        bool                hardwareEnabled;
 
        int                 internalRate;
 
        int                 internalChannels;
 
        bool                muteTxOnTx;
 
        Aec                 aec;
 
        Vad                 vad;
 
        AndroidAudio        android;
 
        Agc                 inputAgc;
 
        Agc                 outputAgc;
 
        bool                denoiseInput;
 
        bool                denoiseOutput;
 
        bool                saveInputPcm;
 
        bool                saveOutputPcm;
 
        AudioRegistry         registry;
 
 
        EnginePolicyAudio()
        {
            clear();
        }
 
        void clear()
        {
            enabled = true;
            hardwareEnabled = true;
            internalRate = 16000;
            internalChannels = 2;
            muteTxOnTx = false;
            aec.clear();
            vad.clear();
            android.clear();
            inputAgc.clear();
            outputAgc.clear();
            denoiseInput = false;
            denoiseOutput = false;
            saveInputPcm = false;
            saveOutputPcm = false;
            registry.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const EnginePolicyAudio& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(hardwareEnabled),
            TOJSON_IMPL(internalRate),
            TOJSON_IMPL(internalChannels),
            TOJSON_IMPL(muteTxOnTx),
            TOJSON_IMPL(aec),
            TOJSON_IMPL(vad),
            TOJSON_IMPL(android),
            TOJSON_IMPL(inputAgc),
            TOJSON_IMPL(outputAgc),
            TOJSON_IMPL(denoiseInput),
            TOJSON_IMPL(denoiseOutput),
            TOJSON_IMPL(saveInputPcm),
            TOJSON_IMPL(saveOutputPcm),
            TOJSON_IMPL(registry)
        };
    }
    static void from_json(const nlohmann::json& j, EnginePolicyAudio& p)
    {
        p.clear();
        getOptional<bool>("enabled", p.enabled, j, true);
        getOptional<bool>("hardwareEnabled", p.hardwareEnabled, j, true);
        FROMJSON_IMPL(internalRate, int, 16000);
        FROMJSON_IMPL(internalChannels, int, 2);
 
        FROMJSON_IMPL(muteTxOnTx, bool, false);
        getOptional<Aec>("aec", p.aec, j);
        getOptional<Vad>("vad", p.vad, j);
        getOptional<AndroidAudio>("android", p.android, j);
        getOptional<Agc>("inputAgc", p.inputAgc, j);
        getOptional<Agc>("outputAgc", p.outputAgc, j);
        FROMJSON_IMPL(denoiseInput, bool, false);
        FROMJSON_IMPL(denoiseOutput, bool, false);
        FROMJSON_IMPL(saveInputPcm, bool, false);
        FROMJSON_IMPL(saveOutputPcm, bool, false);
        getOptional<AudioRegistry>("registry", p.registry, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(SecurityCertificate)
    class SecurityCertificate : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(SecurityCertificate)
 
    public:
 
        std::string         certificate;
 
        std::string         key;
 
        SecurityCertificate()
        {
            clear();
        }
 
        void clear()
        {
            certificate.clear();
            key.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const SecurityCertificate& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(certificate),
            TOJSON_IMPL(key)
        };
    }
    static void from_json(const nlohmann::json& j, SecurityCertificate& p)
    {
        p.clear();
        FROMJSON_IMPL(certificate, std::string, EMPTY_STRING);
        FROMJSON_IMPL(key, std::string, EMPTY_STRING);
    }
 
    // This is where spell checking stops
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EnginePolicySecurity)
 
    
    class EnginePolicySecurity : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EnginePolicySecurity)
 
    public:
 
        SecurityCertificate     certificate;
 
        std::vector<std::string>    caCertificates;
 
        EnginePolicySecurity()
        {
            clear();
        }
 
        void clear()
        {
            certificate.clear();
            caCertificates.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const EnginePolicySecurity& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(certificate),
            TOJSON_IMPL(caCertificates)
        };
    }
    static void from_json(const nlohmann::json& j, EnginePolicySecurity& p)
    {
        p.clear();
        getOptional("certificate", p.certificate, j);
        getOptional<std::vector<std::string>>("caCertificates", p.caCertificates, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EnginePolicyLogging)
    class EnginePolicyLogging : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EnginePolicyLogging)
 
    public:
 
        int     maxLevel;
 
        bool    enableSyslog;
 
        EnginePolicyLogging()
        {
            clear();
        }
 
        void clear()
        {
            maxLevel = 4;                                   // ILogger::Level::debug
            enableSyslog = false;
        }
    };
 
    static void to_json(nlohmann::json& j, const EnginePolicyLogging& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(maxLevel),
            TOJSON_IMPL(enableSyslog)
        };
    }
    static void from_json(const nlohmann::json& j, EnginePolicyLogging& p)
    {
        p.clear();
        getOptional("maxLevel", p.maxLevel, j, 4);          // ILogger::Level::debug
        getOptional("enableSyslog", p.enableSyslog, j);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EnginePolicyDatabase)
    class EnginePolicyDatabase : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EnginePolicyDatabase)
 
    public:
        typedef enum
        {
            dbtFixedMemory          = 0,
            dbtPagedMemory          = 1,
            dbtFixedFile            = 2
        } DatabaseType_t;
 
        DatabaseType_t      type;
        std::string         fixedFileName;
        bool                forceMaintenance;
        bool                reclaimSpace;
 
        EnginePolicyDatabase()
        {
            clear();
        }
 
        void clear()
        {
            type = DatabaseType_t::dbtFixedMemory;
            fixedFileName.clear();
            forceMaintenance = false;
            reclaimSpace = false;
        }
    };
 
    static void to_json(nlohmann::json& j, const EnginePolicyDatabase& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(type),
            TOJSON_IMPL(fixedFileName),
            TOJSON_IMPL(forceMaintenance),
            TOJSON_IMPL(reclaimSpace)
        };
    }
    static void from_json(const nlohmann::json& j, EnginePolicyDatabase& p)
    {
        p.clear();
        FROMJSON_IMPL(type, EnginePolicyDatabase::DatabaseType_t, EnginePolicyDatabase::DatabaseType_t::dbtFixedMemory);
        FROMJSON_IMPL(fixedFileName, std::string, EMPTY_STRING);
        FROMJSON_IMPL(forceMaintenance, bool, false);
        FROMJSON_IMPL(reclaimSpace, bool, false);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(SecureSignature)
    class SecureSignature : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(SecureSignature)
 
    public:
 
        std::string         certificate;
 
        // /** @brief Contains the PEM-formatted text of the certificate's public key */
        //std::string         publicKey;
 
        std::string         signature;
 
        SecureSignature()
        {
            clear();
        }
 
        void clear()
        {
            certificate.clear();
            //publicKey.clear();
            signature.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const SecureSignature& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(certificate),
            //TOJSON_IMPL(publicKey),
            TOJSON_IMPL(signature)
        };
    }
    static void from_json(const nlohmann::json& j, SecureSignature& p)
    {
        p.clear();
        FROMJSON_IMPL(certificate, std::string, EMPTY_STRING);
        //FROMJSON_IMPL(publicKey, std::string, EMPTY_STRING);
        FROMJSON_IMPL(signature, std::string, EMPTY_STRING);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(NamedAudioDevice)
    class NamedAudioDevice : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(NamedAudioDevice)
 
    public:
        std::string                 name;
        std::string                 manufacturer;
        std::string                 model;
        std::string                 id;
        std::string                 serialNumber;
        std::string                 type;
        std::string                 extra;
        bool                        isDefault;
 
        NamedAudioDevice()
        {
            clear();
        }
 
        void clear()
        {
            name.clear();
            manufacturer.clear();
            model.clear();
            id.clear();
            serialNumber.clear();
            type.clear();
            extra.clear();
            isDefault = false;
        }
    };
 
    static void to_json(nlohmann::json& j, const NamedAudioDevice& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(name),
            TOJSON_IMPL(manufacturer),
            TOJSON_IMPL(model),
            TOJSON_IMPL(id),
            TOJSON_IMPL(serialNumber),
            TOJSON_IMPL(type),
            TOJSON_IMPL(extra),
            TOJSON_IMPL(isDefault),
        };
    }
    static void from_json(const nlohmann::json& j, NamedAudioDevice& p)
    {
        p.clear();
        getOptional<std::string>("name", p.name, j, EMPTY_STRING);
        getOptional<std::string>("manufacturer", p.manufacturer, j, EMPTY_STRING);
        getOptional<std::string>("model", p.model, j, EMPTY_STRING);
        getOptional<std::string>("id", p.id, j, EMPTY_STRING);
        getOptional<std::string>("serialNumber", p.serialNumber, j, EMPTY_STRING);
        getOptional<std::string>("type", p.type, j, EMPTY_STRING);
        getOptional<std::string>("extra", p.extra, j, EMPTY_STRING);
        getOptional<bool>("isDefault", p.isDefault, j, false);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EnginePolicyNamedAudioDevices)
    class EnginePolicyNamedAudioDevices : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EnginePolicyNamedAudioDevices)
 
    public:
        std::vector<NamedAudioDevice>    inputs;
        std::vector<NamedAudioDevice>    outputs;
 
        EnginePolicyNamedAudioDevices()
        {
            clear();
        }
 
        void clear()
        {
            inputs.clear();
            outputs.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const EnginePolicyNamedAudioDevices& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(inputs),
            TOJSON_IMPL(outputs)
        };
    }
    static void from_json(const nlohmann::json& j, EnginePolicyNamedAudioDevices& p)
    {
        p.clear();
        getOptional<std::vector<NamedAudioDevice>>("inputs", p.inputs, j);
        getOptional<std::vector<NamedAudioDevice>>("outputs", p.outputs, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(Licensing)
    class Licensing : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(Licensing)
 
    public:
 
        std::string         entitlement;
 
        std::string         key;
 
        std::string         activationCode;
 
        std::string         deviceId;
 
        std::string         manufacturerId;
 
        Licensing()
        {
            clear();
        }
 
        void clear()
        {
            entitlement.clear();
            key.clear();
            activationCode.clear();
            deviceId.clear();
            manufacturerId.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const Licensing& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(entitlement),
            TOJSON_IMPL(key),
            TOJSON_IMPL(activationCode),
            TOJSON_IMPL(deviceId),
            TOJSON_IMPL(manufacturerId)
        };
    }
    static void from_json(const nlohmann::json& j, Licensing& p)
    {
        p.clear();
        FROMJSON_IMPL(entitlement, std::string, EMPTY_STRING);
        FROMJSON_IMPL(key, std::string, EMPTY_STRING);
        FROMJSON_IMPL(activationCode, std::string, EMPTY_STRING);
        FROMJSON_IMPL(deviceId, std::string, EMPTY_STRING);
        FROMJSON_IMPL(manufacturerId, std::string, EMPTY_STRING);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(DiscoveryMagellan)
    class DiscoveryMagellan : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(DiscoveryMagellan)
 
    public:
 
        bool                                    enabled;
 
        std::string                             interfaceName;
 
        SecurityCertificate                     security;
 
        Tls                                         tls;
 
        DiscoveryMagellan()
        {
            clear();
        }
 
        void clear()
        {
            enabled = false;
            interfaceName.clear();
            security.clear();
            tls.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const DiscoveryMagellan& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(interfaceName),
            TOJSON_IMPL(security),
            TOJSON_IMPL(tls)
        };
    }
    static void from_json(const nlohmann::json& j, DiscoveryMagellan& p)
    {
        p.clear();
        getOptional("enabled", p.enabled, j, false);
        getOptional<Tls>("tls", p.tls, j);
        getOptional<SecurityCertificate>("security", p.security, j);
        FROMJSON_IMPL(interfaceName, std::string, EMPTY_STRING);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(DiscoverySsdp)
    class DiscoverySsdp : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(DiscoverySsdp)
 
    public:
 
        bool                                    enabled;
 
        std::string                             interfaceName;
 
        NetworkAddress                          address;
 
        std::vector<std::string>                searchTerms;
 
        int                                     ageTimeoutMs;
 
        Advertising                             advertising;
 
        DiscoverySsdp()
        {
            clear();
        }
 
        void clear()
        {
            enabled = false;
            interfaceName.clear();
            address.clear();
            searchTerms.clear();
            ageTimeoutMs = 30000;
            advertising.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const DiscoverySsdp& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(interfaceName),
            TOJSON_IMPL(address),
            TOJSON_IMPL(searchTerms),
            TOJSON_IMPL(ageTimeoutMs),
            TOJSON_IMPL(advertising)
        };
    }
    static void from_json(const nlohmann::json& j, DiscoverySsdp& p)
    {
        p.clear();
        getOptional("enabled", p.enabled, j, false);
        getOptional<std::string>("interfaceName", p.interfaceName, j);
 
        getOptional<NetworkAddress>("address", p.address, j);
        if(p.address.address.empty())
        {
            p.address.address = "255.255.255.255";
        }
        if(p.address.port <= 0)
        {
            p.address.port = 1900;
        }
 
        getOptional<std::vector<std::string>>("searchTerms", p.searchTerms, j);
        getOptional<int>("ageTimeoutMs", p.ageTimeoutMs, j, 30000);
        getOptional<Advertising>("advertising", p.advertising, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(DiscoverySap)
    class DiscoverySap : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(DiscoverySap)
 
    public:
        bool                                    enabled;
 
        std::string                             interfaceName;
 
        NetworkAddress                          address;
 
        int                                     ageTimeoutMs;
 
        Advertising                             advertising;
 
        DiscoverySap()
        {
            clear();
        }
 
        void clear()
        {
            enabled = false;
            interfaceName.clear();
            address.clear();
            ageTimeoutMs = 30000;
            advertising.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const DiscoverySap& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(interfaceName),
            TOJSON_IMPL(address),
            TOJSON_IMPL(ageTimeoutMs),
            TOJSON_IMPL(advertising)
        };
    }
    static void from_json(const nlohmann::json& j, DiscoverySap& p)
    {
        p.clear();
        getOptional("enabled", p.enabled, j, false);
        getOptional<std::string>("interfaceName", p.interfaceName, j);
        getOptional<NetworkAddress>("address", p.address, j);
        if(p.address.address.empty())
        {
            p.address.address = "224.2.127.254";
        }
        if(p.address.port <= 0)
        {
            p.address.port = 9875;
        }
 
        getOptional<int>("ageTimeoutMs", p.ageTimeoutMs, j, 30000);
        getOptional<Advertising>("advertising", p.advertising, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(DiscoveryCistech)
    class DiscoveryCistech : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(DiscoveryCistech)
 
    public:
        bool                                    enabled;
        std::string                             interfaceName;
        NetworkAddress                          address;
        int                                     ageTimeoutMs;
 
        DiscoveryCistech()
        {
            clear();
        }
 
        void clear()
        {
            enabled = false;
            interfaceName.clear();
            address.clear();
            ageTimeoutMs = 30000;
        }
    };
 
    static void to_json(nlohmann::json& j, const DiscoveryCistech& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(interfaceName),
            TOJSON_IMPL(address),
            TOJSON_IMPL(ageTimeoutMs)
        };
    }
    static void from_json(const nlohmann::json& j, DiscoveryCistech& p)
    {
        p.clear();
        getOptional("enabled", p.enabled, j, false);
        getOptional<std::string>("interfaceName", p.interfaceName, j);
        getOptional<NetworkAddress>("address", p.address, j);
        getOptional<int>("ageTimeoutMs", p.ageTimeoutMs, j, 30000);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(DiscoveryTrellisware)
    class DiscoveryTrellisware : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(DiscoveryTrellisware)
 
    public:
 
        bool                                    enabled;
 
        SecurityCertificate                     security;
 
        DiscoveryTrellisware()
        {
            clear();
        }
 
        void clear()
        {
            enabled = false;
            security.clear();            
        }
    };
 
    static void to_json(nlohmann::json& j, const DiscoveryTrellisware& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(security)
        };
    }
    static void from_json(const nlohmann::json& j, DiscoveryTrellisware& p)
    {
        p.clear();
        getOptional("enabled", p.enabled, j, false);
        getOptional<SecurityCertificate>("security", p.security, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(DiscoveryConfiguration)
    class DiscoveryConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(DiscoveryConfiguration)
 
    public:
        DiscoveryMagellan                       magellan;
 
        DiscoverySsdp                           ssdp;
 
        DiscoverySap                            sap;
 
        DiscoveryCistech                        cistech;
 
        DiscoveryTrellisware                    trellisware;
 
        DiscoveryConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            magellan.clear();
            ssdp.clear();
            sap.clear();
            cistech.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const DiscoveryConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(magellan),
            TOJSON_IMPL(ssdp),
            TOJSON_IMPL(sap),
            TOJSON_IMPL(cistech),
            TOJSON_IMPL(trellisware)
        };
    }
    static void from_json(const nlohmann::json& j, DiscoveryConfiguration& p)
    {
        p.clear();
        getOptional<DiscoveryMagellan>("magellan", p.magellan, j);
        getOptional<DiscoverySsdp>("ssdp", p.ssdp, j);
        getOptional<DiscoverySap>("sap", p.sap, j);
        getOptional<DiscoveryCistech>("cistech", p.cistech, j);
        getOptional<DiscoveryTrellisware>("trellisware", p.trellisware, j);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EnginePolicyInternals)
    class EnginePolicyInternals : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EnginePolicyInternals)
 
    public:
        WatchdogSettings    watchdog;
 
        int                 housekeeperIntervalMs;
 
        int                 maxTxSecs;
 
        int                 maxRxSecs;
 
        int                 logTaskQueueStatsIntervalMs;
 
        bool                enableLazySpeakerClosure;
 
        int                 uriStreamingIntervalMs;
 
        RallypointCluster::ConnectionStrategy_t rpClusterStrategy;
 
        int                                     rpClusterRolloverSecs;
 
        int                                     rtpExpirationCheckIntervalMs;
 
        int                                     rpConnectionTimeoutSecs;
 
        int                                     rpTransactionTimeoutMs;        
 
        int                                     stickyTidHangSecs;
 
        int                                     delayedMicrophoneClosureSecs;
 
        TuningSettings                          tuning; 
 
        EnginePolicyInternals()
        {
            clear();
        }
 
        void clear()
        {
            watchdog.clear();
            housekeeperIntervalMs = 1000;
            logTaskQueueStatsIntervalMs = 0;
            maxTxSecs = 30;
            maxRxSecs = 0;
            enableLazySpeakerClosure = false;
            rpClusterStrategy = RallypointCluster::ConnectionStrategy_t::csRoundRobin;
            rpClusterRolloverSecs = 10;
            rtpExpirationCheckIntervalMs = 250;
            rpConnectionTimeoutSecs = 0;
            rpTransactionTimeoutMs = 0;
            stickyTidHangSecs = 10;
            uriStreamingIntervalMs = 60;
            delayedMicrophoneClosureSecs = 15;
            tuning.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const EnginePolicyInternals& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(watchdog),
            TOJSON_IMPL(housekeeperIntervalMs),
            TOJSON_IMPL(logTaskQueueStatsIntervalMs),
            TOJSON_IMPL(maxTxSecs),
            TOJSON_IMPL(maxRxSecs),
            TOJSON_IMPL(enableLazySpeakerClosure),
            TOJSON_IMPL(rpClusterStrategy),
            TOJSON_IMPL(rpClusterRolloverSecs),
            TOJSON_IMPL(rtpExpirationCheckIntervalMs),
            TOJSON_IMPL(rpConnectionTimeoutSecs),
            TOJSON_IMPL(rpTransactionTimeoutMs),            
            TOJSON_IMPL(stickyTidHangSecs),
            TOJSON_IMPL(uriStreamingIntervalMs),
            TOJSON_IMPL(delayedMicrophoneClosureSecs),
            TOJSON_IMPL(tuning)
        };
    }
    static void from_json(const nlohmann::json& j, EnginePolicyInternals& p)
    {
        p.clear();
        getOptional<WatchdogSettings>("watchdog", p.watchdog, j);
        getOptional<int>("housekeeperIntervalMs", p.housekeeperIntervalMs, j, 1000);
        getOptional<int>("logTaskQueueStatsIntervalMs", p.logTaskQueueStatsIntervalMs, j, 0);
        getOptional<int>("maxTxSecs", p.maxTxSecs, j, 30);
        getOptional<int>("maxRxSecs", p.maxRxSecs, j, 0);
        getOptional<bool>("enableLazySpeakerClosure", p.enableLazySpeakerClosure, j, false);
        getOptional<RallypointCluster::ConnectionStrategy_t>("rpClusterStrategy", p.rpClusterStrategy, j, RallypointCluster::ConnectionStrategy_t::csRoundRobin);
        getOptional<int>("rpClusterRolloverSecs", p.rpClusterRolloverSecs, j, 10);
        getOptional<int>("rtpExpirationCheckIntervalMs", p.rtpExpirationCheckIntervalMs, j, 250);
        getOptional<int>("rpConnectionTimeoutSecs", p.rpConnectionTimeoutSecs, j, 0);
        getOptional<int>("rpTransactionTimeoutMs", p.rpTransactionTimeoutMs, j, 0);
        getOptional<int>("stickyTidHangSecs", p.stickyTidHangSecs, j, 10);
        getOptional<int>("uriStreamingIntervalMs", p.uriStreamingIntervalMs, j, 60);
        getOptional<int>("delayedMicrophoneClosureSecs", p.delayedMicrophoneClosureSecs, j, 15);      
        getOptional<TuningSettings>("tuning", p.tuning, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EnginePolicyTimelines)
    class EnginePolicyTimelines : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EnginePolicyTimelines)
 
    public:
 
        bool                                    enabled;
 
        std::string                             storageRoot;
 
        int                                     maxStorageMb;
 
        int                                     maxMemMb;
 
        int                                     maxAudioEventMemMb;
 
        int                                     maxDiskMb;
 
        long                                    maxEventAgeSecs;
 
        int                                     maxEvents;
 
        long                                    groomingIntervalSecs;
 
        SecurityCertificate                     security;
 
        long                                    autosaveIntervalSecs;
 
        bool                                    disableSigningAndVerification;
 
        bool                                    ephemeral;
 
        EnginePolicyTimelines()
        {
            clear();
        }
 
        void clear()
        {
            enabled = true;
            storageRoot.clear();
            maxStorageMb = 1024;                    // 1 Gigabyte
            maxMemMb = maxStorageMb;
            maxAudioEventMemMb = maxMemMb;
            maxDiskMb = maxStorageMb;
            maxEventAgeSecs = (86400 * 30);         // 30 days
            groomingIntervalSecs = (60 * 30);       // 30 minutes
            maxEvents = 1000;
            autosaveIntervalSecs = 5;
            security.clear();
            disableSigningAndVerification = false;
            ephemeral = false;
        }
    };
 
    static void to_json(nlohmann::json& j, const EnginePolicyTimelines& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(storageRoot),
            TOJSON_IMPL(maxMemMb),
            TOJSON_IMPL(maxAudioEventMemMb),            
            TOJSON_IMPL(maxDiskMb),
            TOJSON_IMPL(maxEventAgeSecs),
            TOJSON_IMPL(maxEvents),
            TOJSON_IMPL(groomingIntervalSecs),
            TOJSON_IMPL(autosaveIntervalSecs),
            TOJSON_IMPL(security),
            TOJSON_IMPL(disableSigningAndVerification),
            TOJSON_IMPL(ephemeral)
        };
    }
    static void from_json(const nlohmann::json& j, EnginePolicyTimelines& p)
    {
        p.clear();
        getOptional<bool>("enabled", p.enabled, j, true);
        getOptional<std::string>("storageRoot", p.storageRoot, j, EMPTY_STRING);
 
        getOptional<int>("maxStorageMb", p.maxStorageMb, j, 1024);
        getOptional<int>("maxMemMb", p.maxMemMb, j, p.maxStorageMb);
        getOptional<int>("maxAudioEventMemMb", p.maxAudioEventMemMb, j, p.maxMemMb);        
        getOptional<int>("maxDiskMb", p.maxDiskMb, j, p.maxStorageMb);
        getOptional<long>("maxEventAgeSecs", p.maxEventAgeSecs, j, (86400 * 30));
        getOptional<long>("groomingIntervalSecs", p.groomingIntervalSecs, j, (60 * 30));
        getOptional<long>("autosaveIntervalSecs", p.autosaveIntervalSecs, j, 5);
        getOptional<int>("maxEvents", p.maxEvents, j, 1000);
        getOptional<SecurityCertificate>("security", p.security, j);
        getOptional<bool>("disableSigningAndVerification", p.disableSigningAndVerification, j, false);
        getOptional<bool>("ephemeral", p.ephemeral, j, false);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RtpMapEntry)
    class RtpMapEntry : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RtpMapEntry)
 
    public:
        std::string         name;
 
        int                 engageType;
 
        int                 rtpPayloadType;
 
        RtpMapEntry()
        {
            clear();
        }
 
        void clear()
        {
            name.clear();
            engageType = -1;
            rtpPayloadType = -1;
        }
    };
 
    static void to_json(nlohmann::json& j, const RtpMapEntry& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(name),
            TOJSON_IMPL(engageType),
            TOJSON_IMPL(rtpPayloadType)
        };
    }
    static void from_json(const nlohmann::json& j, RtpMapEntry& p)
    {
        p.clear();
        getOptional<std::string>("name", p.name, j, EMPTY_STRING);
        getOptional<int>("engageType", p.engageType, j, -1);
        getOptional<int>("rtpPayloadType", p.rtpPayloadType, j, -1);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(ExternalModule)
    class ExternalModule : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(ExternalModule)
 
    public:
        std::string                             name;
 
        std::string                             file;
 
        nlohmann::json                          configuration;
 
        ExternalModule()
        {
            clear();
        }
 
        void clear()
        {
            name.clear();
            file.clear();
            configuration.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const ExternalModule& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(name),
            TOJSON_IMPL(file)
        };        
 
        if(!p.configuration.empty())
        {
            j["configuration"] = p.configuration;
        }
    }
    static void from_json(const nlohmann::json& j, ExternalModule& p)
    {
        p.clear();
        getOptional<std::string>("name", p.name, j, EMPTY_STRING);
        getOptional<std::string>("file", p.file, j, EMPTY_STRING);
        
        try
        {
            p.configuration = j.at("configuration");
        }
        catch(...)
        {
            p.configuration.clear();
        }
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(ExternalCodecDescriptor)
    class ExternalCodecDescriptor : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(ExternalCodecDescriptor)
 
    public:
        int                         rtpPayloadType;
 
        int                         samplingRate;
 
        int                         channels;
 
        int                         rtpTsMultiplier;
 
        ExternalCodecDescriptor()
        {            
            clear();
        }
 
        void clear()
        {
            rtpPayloadType = -1;
            samplingRate = -1;
            channels = -1;
            rtpTsMultiplier = 0;
        }
    };
 
    static void to_json(nlohmann::json& j, const ExternalCodecDescriptor& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(rtpPayloadType),
            TOJSON_IMPL(samplingRate),
            TOJSON_IMPL(channels),
            TOJSON_IMPL(rtpTsMultiplier)
        };
    }
    static void from_json(const nlohmann::json& j, ExternalCodecDescriptor& p)
    {
        p.clear();
                
        getOptional<int>("rtpPayloadType", p.rtpPayloadType, j, -1);
        getOptional<int>("samplingRate", p.samplingRate, j, -1);
        getOptional<int>("channels", p.channels, j, -1);
        getOptional<int>("rtpTsMultiplier", p.rtpTsMultiplier, j, -1);
    }
    
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EngineStatusReportConfiguration)
    class EngineStatusReportConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EngineStatusReportConfiguration)
 
    public:
        std::string                     fileName;
 
        int                             intervalSecs;
 
        bool                            enabled;
 
        std::string                     runCmd;
 
        bool                            includeMemoryDetail;
 
        bool                            includeTaskQueueDetail;
 
        EngineStatusReportConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            fileName.clear();
            intervalSecs = 60;
            enabled = false;
            includeMemoryDetail = false;
            includeTaskQueueDetail = false;
            runCmd.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const EngineStatusReportConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(fileName),
            TOJSON_IMPL(intervalSecs),
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(includeMemoryDetail),
            TOJSON_IMPL(includeTaskQueueDetail),
            TOJSON_IMPL(runCmd)
        };
    }
    static void from_json(const nlohmann::json& j, EngineStatusReportConfiguration& p)
    {
        p.clear();
        getOptional<std::string>("fileName", p.fileName, j);
        getOptional<int>("intervalSecs", p.intervalSecs, j, 60);
        getOptional<bool>("enabled", p.enabled, j, false);
        getOptional<std::string>("runCmd", p.runCmd, j);
        getOptional<bool>("includeMemoryDetail", p.includeMemoryDetail, j, false);
        getOptional<bool>("includeTaskQueueDetail", p.includeTaskQueueDetail, j, false);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EnginePolicy)
    class EnginePolicy : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EnginePolicy)
 
    public:
 
        std::string                 dataDirectory;
 
        Licensing                   licensing;
 
        EnginePolicySecurity        security;
 
        EnginePolicyNetworking      networking;
 
        EnginePolicyAudio           audio;
 
        DiscoveryConfiguration      discovery;
 
        EnginePolicyLogging         logging;
 
        EnginePolicyInternals       internals;
 
        EnginePolicyTimelines       timelines;
 
        EnginePolicyDatabase        database;
 
        Featureset                  featureset;
 
        EnginePolicyNamedAudioDevices namedAudioDevices;
 
        std::vector<ExternalModule> externalCodecs;
 
        std::vector<RtpMapEntry>    rtpMap;
 
        EngineStatusReportConfiguration statusReport;
 
        EnginePolicy()
        {
            clear();
        }
 
        void clear()
        {
            dataDirectory.clear();
            licensing.clear();
            security.clear();
            networking.clear();
            audio.clear();
            discovery.clear();
            logging.clear();
            internals.clear();
            timelines.clear();
            database.clear();
            featureset.clear();
            namedAudioDevices.clear();
            externalCodecs.clear();
            rtpMap.clear();
            statusReport.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const EnginePolicy& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(dataDirectory),
            TOJSON_IMPL(licensing),
            TOJSON_IMPL(security),
            TOJSON_IMPL(networking),
            TOJSON_IMPL(audio),
            TOJSON_IMPL(discovery),
            TOJSON_IMPL(logging),
            TOJSON_IMPL(internals),
            TOJSON_IMPL(timelines),
            TOJSON_IMPL(database),
            TOJSON_IMPL(featureset),
            TOJSON_IMPL(namedAudioDevices),
            TOJSON_IMPL(externalCodecs),
            TOJSON_IMPL(rtpMap),
            TOJSON_IMPL(statusReport)
        };
    }
    static void from_json(const nlohmann::json& j, EnginePolicy& p)
    {
        p.clear();
        FROMJSON_IMPL_SIMPLE(dataDirectory);
        FROMJSON_IMPL_SIMPLE(licensing);
        FROMJSON_IMPL_SIMPLE(security);
        FROMJSON_IMPL_SIMPLE(networking);
        FROMJSON_IMPL_SIMPLE(audio);
        FROMJSON_IMPL_SIMPLE(discovery);
        FROMJSON_IMPL_SIMPLE(logging);
        FROMJSON_IMPL_SIMPLE(internals);
        FROMJSON_IMPL_SIMPLE(timelines);
        FROMJSON_IMPL_SIMPLE(database);
        FROMJSON_IMPL_SIMPLE(featureset);
        FROMJSON_IMPL_SIMPLE(namedAudioDevices);
        FROMJSON_IMPL_SIMPLE(externalCodecs);
        FROMJSON_IMPL_SIMPLE(rtpMap);
        FROMJSON_IMPL_SIMPLE(statusReport);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(TalkgroupAsset)
    class TalkgroupAsset : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(TalkgroupAsset)
 
    public:
 
        std::string     nodeId;
 
        Group           group;
 
        TalkgroupAsset()
        {
            clear();
        }
 
        void clear()
        {
            nodeId.clear();
            group.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const TalkgroupAsset& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(nodeId),
            TOJSON_IMPL(group)
        };
    }
    static void from_json(const nlohmann::json& j, TalkgroupAsset& p)
    {
        p.clear();
        getOptional<std::string>("nodeId", p.nodeId, j);
        getOptional<Group>("group", p.group, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EngageDiscoveredGroup)
    class EngageDiscoveredGroup : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EngageDiscoveredGroup)
 
    public:
        std::string     id;
 
        int             type;
 
        NetworkAddress  rx;
 
        NetworkAddress  tx;
 
        EngageDiscoveredGroup()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            type = 0;
            rx.clear();
            tx.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const EngageDiscoveredGroup& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(type),
            TOJSON_IMPL(rx),
            TOJSON_IMPL(tx)
        };
    }
    static void from_json(const nlohmann::json& j, EngageDiscoveredGroup& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j);
        getOptional<int>("type", p.type, j, 0);
        getOptional<NetworkAddress>("rx", p.rx, j);
        getOptional<NetworkAddress>("tx", p.tx, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RallypointPeer)
    class RallypointPeer : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RallypointPeer)
 
    public:
        typedef enum
        {
            olpUseRpConfiguration      = 0,
 
            olpIsMeshLeaf   = 1,
 
            olpNotMeshLeaf   = 2
        } OutboundLeafPolicy_t;
 
        typedef enum
        {
            olpUseRpWebSocketTlsConfiguration = 0,
 
            olpUseTlsForWebSocket      = 1,
 
            olpDoNotUseTlsForWebSocket   = 2
        } OutboundWebSocketTlsPolicy_t;
 
        std::string             id;
 
        bool                    enabled;
 
        NetworkAddress          host;
 
        SecurityCertificate     certificate;
 
        int                      connectionTimeoutSecs;
 
        bool                    forceIsMeshLeaf;
 
        OutboundLeafPolicy_t    outboundLeafPolicy;
 
        Rallypoint::RpProtocol_t    protocol;
 
        std::string                     path;
 
        std::string                     additionalProtocols;
 
        OutboundWebSocketTlsPolicy_t        outboundWebSocketTlsPolicy;
 
        RallypointPeer()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            enabled = true;
            host.clear();
            certificate.clear();
            connectionTimeoutSecs = 0;
            forceIsMeshLeaf = false;
            outboundLeafPolicy = OutboundLeafPolicy_t::olpUseRpConfiguration;
            protocol = Rallypoint::RpProtocol_t::rppTlsTcp;
            path.clear();
            additionalProtocols.clear();
            outboundWebSocketTlsPolicy = OutboundWebSocketTlsPolicy_t::olpUseRpWebSocketTlsConfiguration;
        }
    };
 
    static void to_json(nlohmann::json& j, const RallypointPeer& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(host),
            TOJSON_IMPL(certificate),
            TOJSON_IMPL(connectionTimeoutSecs),
            TOJSON_IMPL(forceIsMeshLeaf),
            TOJSON_IMPL(outboundLeafPolicy),
            TOJSON_IMPL(protocol),
            TOJSON_IMPL(path),
            TOJSON_IMPL(additionalProtocols),
            TOJSON_IMPL(outboundWebSocketTlsPolicy)
        };
    }
    static void from_json(const nlohmann::json& j, RallypointPeer& p)
    {
        p.clear();
        j.at("id").get_to(p.id);
        getOptional<bool>("enabled", p.enabled, j, true);
        getOptional<NetworkAddress>("host", p.host, j);
        getOptional<SecurityCertificate>("certificate", p.certificate, j);
        getOptional<int>("connectionTimeoutSecs", p.connectionTimeoutSecs, j, 0);
        getOptional<bool>("forceIsMeshLeaf", p.forceIsMeshLeaf, j, false);
        getOptional<RallypointPeer::OutboundLeafPolicy_t>("outboundLeafPolicy", p.outboundLeafPolicy, j, RallypointPeer::OutboundLeafPolicy_t::olpUseRpConfiguration);
        getOptional<Rallypoint::RpProtocol_t>("protocol", p.protocol, j, Rallypoint::RpProtocol_t::rppTlsTcp);
        getOptional<std::string>("path", p.path, j);
        getOptional<std::string>("additionalProtocols", p.additionalProtocols, j);
        getOptional<RallypointPeer::OutboundWebSocketTlsPolicy_t>("outboundWebSocketTlsPolicy", p.outboundWebSocketTlsPolicy, j, RallypointPeer::OutboundWebSocketTlsPolicy_t::olpUseRpWebSocketTlsConfiguration);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RallypointServerLimits)
    class RallypointServerLimits : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RallypointServerLimits)
 
    public:
        uint32_t            maxClients;
 
        uint32_t            maxPeers;
 
        uint32_t            maxMulticastReflectors;
 
        uint32_t            maxRegisteredStreams;
 
        uint32_t            maxStreamPaths;
 
        uint32_t            maxRxPacketsPerSec;
 
        uint32_t            maxTxPacketsPerSec;
 
        uint32_t            maxRxBytesPerSec;
 
        uint32_t            maxTxBytesPerSec;
 
        uint32_t            maxQOpsPerSec;
 
        uint32_t            maxInboundBacklog;
 
        uint32_t            lowPriorityQueueThreshold;
 
        uint32_t            normalPriorityQueueThreshold;
 
        uint32_t            denyNewConnectionCpuThreshold;
 
        uint32_t            warnAtCpuThreshold;
 
        RallypointServerLimits()
        {
            clear();
        }
 
        void clear()
        {
            maxClients = 0;
            maxPeers = 0;
            maxMulticastReflectors = 0;
            maxRegisteredStreams = 0;
            maxStreamPaths = 0;
            maxRxPacketsPerSec = 0;
            maxTxPacketsPerSec = 0;
            maxRxBytesPerSec = 0;
            maxTxBytesPerSec = 0;
            maxQOpsPerSec = 0;
            maxInboundBacklog = 64;
            lowPriorityQueueThreshold = 64;
            normalPriorityQueueThreshold = 256;
            denyNewConnectionCpuThreshold = 75;
            warnAtCpuThreshold = 65;
        }
    };
 
    static void to_json(nlohmann::json& j, const RallypointServerLimits& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(maxClients),
            TOJSON_IMPL(maxPeers),
            TOJSON_IMPL(maxMulticastReflectors),
            TOJSON_IMPL(maxRegisteredStreams),
            TOJSON_IMPL(maxStreamPaths),
            TOJSON_IMPL(maxRxPacketsPerSec),
            TOJSON_IMPL(maxTxPacketsPerSec),
            TOJSON_IMPL(maxRxBytesPerSec),
            TOJSON_IMPL(maxTxBytesPerSec),
            TOJSON_IMPL(maxQOpsPerSec),
            TOJSON_IMPL(maxInboundBacklog),
            TOJSON_IMPL(lowPriorityQueueThreshold),
            TOJSON_IMPL(normalPriorityQueueThreshold),
            TOJSON_IMPL(denyNewConnectionCpuThreshold),
            TOJSON_IMPL(warnAtCpuThreshold)
        };
    }
    static void from_json(const nlohmann::json& j, RallypointServerLimits& p)
    {
        p.clear();
        getOptional<uint32_t>("maxClients", p.maxClients, j, 0);
        getOptional<uint32_t>("maxPeers", p.maxPeers, j, 0);
        getOptional<uint32_t>("maxMulticastReflectors", p.maxMulticastReflectors, j, 0);
        getOptional<uint32_t>("maxRegisteredStreams", p.maxRegisteredStreams, j, 0);
        getOptional<uint32_t>("maxStreamPaths", p.maxStreamPaths, j, 0);
        getOptional<uint32_t>("maxRxPacketsPerSec", p.maxRxPacketsPerSec, j, 0);
        getOptional<uint32_t>("maxTxPacketsPerSec", p.maxTxPacketsPerSec, j, 0);
        getOptional<uint32_t>("maxRxBytesPerSec", p.maxRxBytesPerSec, j, 0);
        getOptional<uint32_t>("maxTxBytesPerSec", p.maxTxBytesPerSec, j, 0);
        getOptional<uint32_t>("maxQOpsPerSec", p.maxQOpsPerSec, j, 0);
        getOptional<uint32_t>("maxInboundBacklog", p.maxInboundBacklog, j, 64);
        getOptional<uint32_t>("lowPriorityQueueThreshold", p.lowPriorityQueueThreshold, j, 64);
        getOptional<uint32_t>("normalPriorityQueueThreshold", p.normalPriorityQueueThreshold, j, 256);
        getOptional<uint32_t>("denyNewConnectionCpuThreshold", p.denyNewConnectionCpuThreshold, j, 75);
        getOptional<uint32_t>("warnAtCpuThreshold", p.warnAtCpuThreshold, j, 65);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RallypointServerStatusReportConfiguration)
    class RallypointServerStatusReportConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RallypointServerStatusReportConfiguration)
 
    public:
        std::string                     fileName;
 
        int                             intervalSecs;
 
        bool                            enabled;
 
        bool                            includeLinks;
 
        bool                            includePeerLinkDetails;
 
        bool                            includeClientLinkDetails;
 
        std::string                     runCmd;
 
        RallypointServerStatusReportConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            fileName.clear();
            intervalSecs = 60;
            enabled = false;
            includeLinks = false;
            includePeerLinkDetails = false;
            includeClientLinkDetails = false;
            runCmd.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const RallypointServerStatusReportConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(fileName),
            TOJSON_IMPL(intervalSecs),
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(includeLinks),
            TOJSON_IMPL(includePeerLinkDetails),
            TOJSON_IMPL(includeClientLinkDetails),
            TOJSON_IMPL(runCmd)
        };
    }
    static void from_json(const nlohmann::json& j, RallypointServerStatusReportConfiguration& p)
    {
        p.clear();
        getOptional<std::string>("fileName", p.fileName, j);
        getOptional<int>("intervalSecs", p.intervalSecs, j, 60);
        getOptional<bool>("enabled", p.enabled, j, false);
        getOptional<bool>("includeLinks", p.includeLinks, j, false);
        getOptional<bool>("includePeerLinkDetails", p.includePeerLinkDetails, j, false);
        getOptional<bool>("includeClientLinkDetails", p.includeClientLinkDetails, j, false);
        getOptional<std::string>("runCmd", p.runCmd, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RallypointServerLinkGraph)
    class RallypointServerLinkGraph : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RallypointServerLinkGraph)
 
    public:
        std::string                     fileName;
 
        int                             minRefreshSecs;
 
        bool                            enabled;
 
        bool                            includeDigraphEnclosure;
 
        bool                            includeClients;
 
        std::string                     coreRpStyling;
 
        std::string                     leafRpStyling;
 
        std::string                     clientStyling;
 
        std::string                     runCmd;
 
        RallypointServerLinkGraph()
        {
            clear();
        }
 
        void clear()
        {
            fileName.clear();
            minRefreshSecs = 5;
            enabled = false;
            includeDigraphEnclosure = true;
            includeClients = false;
            coreRpStyling = "[shape=hexagon color=firebrick style=filled]";
            leafRpStyling = "[shape=box color=gray style=filled]";
            clientStyling.clear();
            runCmd.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const RallypointServerLinkGraph& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(fileName),
            TOJSON_IMPL(minRefreshSecs),
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(includeDigraphEnclosure),
            TOJSON_IMPL(includeClients),
            TOJSON_IMPL(coreRpStyling),
            TOJSON_IMPL(leafRpStyling),
            TOJSON_IMPL(clientStyling),
            TOJSON_IMPL(runCmd)
        };
    }
    static void from_json(const nlohmann::json& j, RallypointServerLinkGraph& p)
    {
        p.clear();
        getOptional<std::string>("fileName", p.fileName, j);
        getOptional<int>("minRefreshSecs", p.minRefreshSecs, j, 5);
        getOptional<bool>("enabled", p.enabled, j, false);
        getOptional<bool>("includeDigraphEnclosure", p.includeDigraphEnclosure, j, true);
        getOptional<bool>("includeClients", p.includeClients, j, false);
        getOptional<std::string>("coreRpStyling", p.coreRpStyling, j, "[shape=hexagon color=firebrick style=filled]");
        getOptional<std::string>("leafRpStyling", p.leafRpStyling, j, "[shape=box color=gray style=filled]");
        getOptional<std::string>("clientStyling", p.clientStyling, j);
        getOptional<std::string>("runCmd", p.runCmd, j);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RallypointServerStreamStatsExport)
    class RallypointServerStreamStatsExport : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RallypointServerStreamStatsExport)
 
    public:
        typedef enum
        {
            fmtCsv   = 0,
 
            fmtJson = 1
        } ExportFormat_t;
 
        std::string                     fileName;
 
        int                             intervalSecs;
 
        bool                            enabled;
 
        bool                            resetCountersAfterExport;
 
        std::string                     runCmd;
 
        ExportFormat_t                  format;
 
 
        RallypointServerStreamStatsExport()
        {
            clear();
        }
 
        void clear()
        {
            fileName.clear();
            intervalSecs = 60;
            enabled = false;
            resetCountersAfterExport = false;
            runCmd.clear();
            format = fmtJson;
        }
    };
 
    static void to_json(nlohmann::json& j, const RallypointServerStreamStatsExport& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(fileName),
            TOJSON_IMPL(intervalSecs),
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(resetCountersAfterExport),
            TOJSON_IMPL(runCmd),
            TOJSON_IMPL(format)
        };
    }
    static void from_json(const nlohmann::json& j, RallypointServerStreamStatsExport& p)
    {
        p.clear();
        getOptional<std::string>("fileName", p.fileName, j);
        getOptional<int>("intervalSecs", p.intervalSecs, j, 60);
        getOptional<bool>("enabled", p.enabled, j, false);
        getOptional<bool>("resetCountersAfterExport", p.resetCountersAfterExport, j, false);
        getOptional<std::string>("runCmd", p.runCmd, j);
        getOptional<RallypointServerStreamStatsExport::ExportFormat_t>("format", p.format, j, RallypointServerStreamStatsExport::ExportFormat_t::fmtCsv);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RallypointServerRouteMap)
    class RallypointServerRouteMap : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RallypointServerRouteMap)
 
    public:
        std::string                     fileName;
 
        int                             minRefreshSecs;
 
        bool                            enabled;
 
        std::string                     runCmd;
 
        RallypointServerRouteMap()
        {
            clear();
        }
 
        void clear()
        {
            fileName.clear();
            minRefreshSecs = 5;
            enabled = false;
        }
    };
 
    static void to_json(nlohmann::json& j, const RallypointServerRouteMap& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(fileName),
            TOJSON_IMPL(minRefreshSecs),
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(runCmd)
        };
    }
    static void from_json(const nlohmann::json& j, RallypointServerRouteMap& p)
    {
        p.clear();
        getOptional<std::string>("fileName", p.fileName, j);
        getOptional<int>("minRefreshSecs", p.minRefreshSecs, j, 5);
        getOptional<bool>("enabled", p.enabled, j, false);
        getOptional<std::string>("runCmd", p.runCmd, j);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(ExternalHealthCheckResponder)
    class ExternalHealthCheckResponder : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(ExternalHealthCheckResponder)
 
    public:
 
        int                             listenPort;
 
        bool                            immediateClose;
 
        ExternalHealthCheckResponder()
        {
            clear();
        }
 
        void clear()
        {
            listenPort = 0;
            immediateClose = true;
        }
    };
 
    static void to_json(nlohmann::json& j, const ExternalHealthCheckResponder& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(listenPort),
            TOJSON_IMPL(immediateClose)
        };
    }
    static void from_json(const nlohmann::json& j, ExternalHealthCheckResponder& p)
    {
        p.clear();
        getOptional<int>("listenPort", p.listenPort, j, 0);
        getOptional<bool>("immediateClose", p.immediateClose, j, true);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(PeeringConfiguration)
    class PeeringConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(PeeringConfiguration)
 
    public:
 
        std::string                     id;
 
        int                             version;
 
        std::string                     comments;
 
        std::vector<RallypointPeer>     peers;
 
        PeeringConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            version = 0;
            comments.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const PeeringConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(version),
            TOJSON_IMPL(comments),
            TOJSON_IMPL(peers)
        };
    }
    static void from_json(const nlohmann::json& j, PeeringConfiguration& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j);
        getOptional<int>("version", p.version, j, 0);
        getOptional<std::string>("comments", p.comments, j);
        getOptional<std::vector<RallypointPeer>>("peers", p.peers, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(IgmpSnooping)
    class IgmpSnooping : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(IgmpSnooping)
 
    public:
 
        bool                            enabled;
 
        int                             queryIntervalMs;
 
        int                             subscriptionTimeoutMs;
 
 
        IgmpSnooping()
        {
            clear();
        }
 
        void clear()
        {
            enabled = false;
            queryIntervalMs = 125000;
            subscriptionTimeoutMs = 0;
        }
    };
 
    static void to_json(nlohmann::json& j, const IgmpSnooping& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(queryIntervalMs),
            TOJSON_IMPL(subscriptionTimeoutMs)
        };
    }
    static void from_json(const nlohmann::json& j, IgmpSnooping& p)
    {
        p.clear();
        getOptional<bool>("enabled", p.enabled, j);
        getOptional<int>("queryIntervalMs", p.queryIntervalMs, j, 125000);
        getOptional<int>("subscriptionTimeoutMs", p.subscriptionTimeoutMs, j, 0);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RallypointReflector)
    class RallypointReflector : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RallypointReflector)
 
    public:
        typedef enum
        {
            drNone = 0,
 
            drRxOnly   = 1,
 
            drTxOnly   = 2
        } DirectionRestriction_t;
 
        std::string                             id;
 
        NetworkAddress                          rx;
 
        NetworkAddress                          tx;
 
        std::string                             multicastInterfaceName;
 
        std::vector<NetworkAddress>            additionalTx;
 
        DirectionRestriction_t                  directionRestriction;
 
        RallypointReflector()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            rx.clear();
            tx.clear();
            multicastInterfaceName.clear();
            additionalTx.clear();
            directionRestriction = drNone;
        }
    };
 
    static void to_json(nlohmann::json& j, const RallypointReflector& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(rx),
            TOJSON_IMPL(tx),
            TOJSON_IMPL(multicastInterfaceName),
            TOJSON_IMPL(additionalTx),
            TOJSON_IMPL(directionRestriction)
        };
    }
    static void from_json(const nlohmann::json& j, RallypointReflector& p)
    {
        p.clear();
        j.at("id").get_to(p.id);
        j.at("rx").get_to(p.rx);
        j.at("tx").get_to(p.tx);
        getOptional<std::string>("multicastInterfaceName", p.multicastInterfaceName, j);
        getOptional<std::vector<NetworkAddress>>("additionalTx", p.additionalTx, j);
        getOptional<RallypointReflector::DirectionRestriction_t>("directionRestriction", p.directionRestriction, j, RallypointReflector::DirectionRestriction_t::drNone);
    }    
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RallypointUdpStreamingIpvX)
    class RallypointUdpStreamingIpvX : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RallypointUdpStreamingIpvX)
 
    public:
        bool                                    enabled;
 
        NetworkAddress                          external;
 
        RallypointUdpStreamingIpvX()
        {
            clear();
        }
 
        void clear()
        {
            enabled = true;            
            external.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const RallypointUdpStreamingIpvX& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(external)
        };
    }
    static void from_json(const nlohmann::json& j, RallypointUdpStreamingIpvX& p)
    {
        p.clear();
        getOptional<bool>("enabled", p.enabled, j, true);        
        getOptional<NetworkAddress>("external", p.external, j);
    }    
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RallypointUdpStreaming)
    class RallypointUdpStreaming : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RallypointUdpStreaming)
 
    public:
        typedef enum
        {
            ctUnknown                   = 0,
 
            ctSharedKeyAes256FullIv     = 1,
 
            ctSharedKeyAes256IdxIv      = 2,
 
            ctSharedKeyChaCha20FullIv   = 3,
 
            ctSharedKeyChaCha20IdxIv    = 4
        } CryptoType_t;
 
        bool                                enabled;
 
        CryptoType_t                        cryptoType;
 
        int                                 listenPort;
 
        RallypointUdpStreamingIpvX          ipv4;
 
        RallypointUdpStreamingIpvX          ipv6;
 
        int                                 keepaliveIntervalSecs;
 
        TxPriority_t                        priority;
 
        int                                 ttl;
 
 
        RallypointUdpStreaming()
        {
            clear();
        }
 
        void clear()
        {
            enabled = true;
            cryptoType = CryptoType_t::ctSharedKeyAes256FullIv;
            listenPort = 7444;
            ipv4.clear();
            ipv6.clear();
            keepaliveIntervalSecs = 15;
            priority = TxPriority_t::priVoice;
            ttl = 64;
        }
    };
 
    static void to_json(nlohmann::json& j, const RallypointUdpStreaming& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(cryptoType),
            TOJSON_IMPL(listenPort),
            TOJSON_IMPL(keepaliveIntervalSecs),
            TOJSON_IMPL(ipv4),
            TOJSON_IMPL(ipv6),
            TOJSON_IMPL(priority),
            TOJSON_IMPL(ttl)
        };
    }
    static void from_json(const nlohmann::json& j, RallypointUdpStreaming& p)
    {
        p.clear();
        getOptional<bool>("enabled", p.enabled, j, true);
        getOptional<RallypointUdpStreaming::CryptoType_t>("cryptoType", p.cryptoType, j, RallypointUdpStreaming::CryptoType_t::ctSharedKeyAes256FullIv);
        getOptional<int>("listenPort", p.listenPort, j, 7444);
        getOptional<int>("keepaliveIntervalSecs", p.keepaliveIntervalSecs, j, 15);
        getOptional<RallypointUdpStreamingIpvX>("ipv4", p.ipv4, j);
        getOptional<RallypointUdpStreamingIpvX>("ipv6", p.ipv6, j);
        getOptional<TxPriority_t>("priority", p.priority, j, TxPriority_t::priVoice);
        getOptional<int>("ttl", p.ttl, j, 64);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RallypointRpRtTimingBehavior)
    class RallypointRpRtTimingBehavior : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RallypointRpRtTimingBehavior)
 
    public:
        typedef enum
        {
            btNone,
 
            btReportInfo,
 
            btReportWarn,
 
            btReportError,  
 
            btDrop = 99        
        } BehaviorType_t;
 
        BehaviorType_t                          behavior;
 
        uint32_t                                atOrAboveMs;
 
        std::string                             runCmd;
 
        RallypointRpRtTimingBehavior()
        {
            clear();
        }
 
        void clear()
        {
            behavior = btNone;
            atOrAboveMs = 0;
            runCmd.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const RallypointRpRtTimingBehavior& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(behavior),
            TOJSON_IMPL(atOrAboveMs),
            TOJSON_IMPL(runCmd)
        };
    }
    static void from_json(const nlohmann::json& j, RallypointRpRtTimingBehavior& p)
    {
        p.clear();
        getOptional<RallypointRpRtTimingBehavior::BehaviorType_t>("behavior", p.behavior, j, RallypointRpRtTimingBehavior::BehaviorType_t::btNone);
        getOptional<uint32_t>("atOrAboveMs", p.atOrAboveMs, j, 0);
        getOptional<std::string>("runCmd", p.runCmd, j);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RallypointWebsocketSettings)
    class RallypointWebsocketSettings : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RallypointWebsocketSettings)
 
    public:
        bool                                    enabled;
 
        int                                     listenPort;
 
        SecurityCertificate                     certificate;
 
        bool                                    requireClientCertificate;
 
        bool                                    requireTls;
 
        RallypointWebsocketSettings()
        {
            clear();
        }
 
        void clear()
        {
            enabled = false;
            listenPort = 8443;
            certificate.clear();
            requireClientCertificate = false;
            requireTls = true;
        }
    };
 
    static void to_json(nlohmann::json& j, const RallypointWebsocketSettings& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(listenPort),
            TOJSON_IMPL(certificate),
            TOJSON_IMPL(requireClientCertificate),
            TOJSON_IMPL(requireTls)
        };
    }
    static void from_json(const nlohmann::json& j, RallypointWebsocketSettings& p)
    {
        p.clear();
        getOptional<bool>("enabled", p.enabled, j, false);
        getOptional<int>("listenPort", p.listenPort, j, 8443);
        getOptional<SecurityCertificate>("certificate", p.certificate, j);
        getOptional<bool>("requireClientCertificate", p.requireClientCertificate, j, false);
        getOptional<bool>("requireTls", p.requireTls, j, true);
    }
 
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RallypointAdvertisingSettings)
    class RallypointAdvertisingSettings : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RallypointAdvertisingSettings)
 
    public:
        bool                                    enabled;
 
        std::string                             hostName;
 
        std::string                             serviceName;
 
        std::string                             interfaceName;
 
        int                                     port;
 
        int                                     ttl;
 
        RallypointAdvertisingSettings()
        {
            clear();
        }
 
        void clear()
        {
            enabled = false;
            hostName.clear();
            serviceName = "_rallypoint._tcp.local.";
            interfaceName.clear();
            port = 0;
            ttl = 60;
        }
    };
 
    static void to_json(nlohmann::json& j, const RallypointAdvertisingSettings& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(hostName),
            TOJSON_IMPL(serviceName),
            TOJSON_IMPL(interfaceName),
            TOJSON_IMPL(port),
            TOJSON_IMPL(ttl)
        };
    }
    static void from_json(const nlohmann::json& j, RallypointAdvertisingSettings& p)
    {
        p.clear();
        getOptional<bool>("enabled", p.enabled, j, false);
        getOptional<std::string>("hostName", p.hostName, j);
        getOptional<std::string>("serviceName", p.serviceName, j, "_rallypoint._tcp.local.");
        getOptional<std::string>("interfaceName", p.interfaceName, j);
 
        getOptional<int>("port", p.port, j, 0);
        getOptional<int>("ttl", p.ttl, j, 60);
    }
 
 
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(NamedIdentity)
    class NamedIdentity : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(NamedIdentity)
 
    public:
        std::string                             name;
 
        SecurityCertificate                     certificate;
 
        NamedIdentity()
        {
            clear();
        }
 
        void clear()
        {
            name.clear();
            certificate.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const NamedIdentity& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(name),
            TOJSON_IMPL(certificate)
        };
    }
    static void from_json(const nlohmann::json& j, NamedIdentity& p)
    {
        p.clear();
        getOptional<std::string>("name", p.name, j);
        getOptional<SecurityCertificate>("certificate", p.certificate, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RallypointExtendedGroupRestriction)
    class RallypointExtendedGroupRestriction : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RallypointExtendedGroupRestriction)
 
    public:
        std::string                             id;
 
        std::vector<StringRestrictionList>      restrictions;
 
        RallypointExtendedGroupRestriction()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            restrictions.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const RallypointExtendedGroupRestriction& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(restrictions)
        };
    }
    static void from_json(const nlohmann::json& j, RallypointExtendedGroupRestriction& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j);
        getOptional<std::vector<StringRestrictionList>>("restrictions", p.restrictions, j);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RallypointServer)
    class RallypointServer : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RallypointServer)
 
    public:        
        typedef enum
        {
            sptDefault              = 0,
            sptCertificate          = 1,
            sptCertPublicKey        = 2,
            sptCertSubject          = 3,
            sptCertIssuer           = 4,
            sptCertFingerprint      = 5,
            sptCertSerial           = 6,
            sptSubjectC             = 7,
            sptSubjectST            = 8,
            sptSubjectL             = 9,
            sptSubjectO             = 10,
            sptSubjectOU            = 11,
            sptSubjectCN            = 12,
            sptIssuerC              = 13,
            sptIssuerST             = 14,
            sptIssuerL              = 15,
            sptIssuerO              = 16,
            sptIssuerOU             = 17,
            sptIssuerCN             = 18
        } StreamIdPrivacyType_t;
 
        StreamIdPrivacyType_t                       streamIdPrivacyType;
 
        FipsCryptoSettings                          fipsCrypto;
    
        WatchdogSettings                            watchdog;
 
        std::string                                 id;
 
        std::string                                 name;
 
        int                                         listenPort;
 
        IpFamilyType_t                              ipFamily;
 
        std::string                                 interfaceName;
 
        SecurityCertificate                         certificate;
 
        std::string                                 peeringConfigurationFileName;
 
        std::string                                 peeringConfigurationFileCommand;
 
        int                                         peeringConfigurationFileCheckSecs;
 
        bool                                        allowMulticastForwarding;
 
        int                                         ioPools;
 
        RallypointServerStatusReportConfiguration   statusReport;
 
        RallypointServerLimits                      limits;
 
        RallypointServerLinkGraph                   linkGraph;
 
        ExternalHealthCheckResponder                externalHealthCheckResponder;
 
        bool                                        allowPeerForwarding;
 
        std::string                                 multicastInterfaceName;
 
        Tls                                         tls;
 
        DiscoveryConfiguration                      discovery;
 
        bool                                        forwardDiscoveredGroups;
 
        bool                                        forwardMulticastAddressing;
 
        PeeringConfiguration                        peeringConfiguration;       // NOTE: This is NOT serialized
 
        bool                                        isMeshLeaf;
 
        bool                                        disableMessageSigning;
 
        NetworkAddressRestrictionList               multicastRestrictions;
 
        IgmpSnooping                                igmpSnooping;
 
        std::vector<RallypointReflector>            staticReflectors;
 
        TcpNetworkTxOptions                         tcpTxOptions;
 
        NetworkTxOptions                            multicastTxOptions;
 
        std::string                                 certStoreFileName;
 
        std::string                                 certStorePasswordHex;
 
        StringRestrictionList                       groupRestrictions;
 
        GroupRestrictionAccessPolicyType_t          groupRestrictionAccessPolicyType;
 
        std::vector<RallypointExtendedGroupRestriction>       extendedGroupRestrictions;
 
        std::string                                 configurationCheckSignalName;
 
        Licensing                                   licensing;
 
        Featureset                                  featureset;
 
        RallypointUdpStreaming                      udpStreaming;
 
        uint32_t                                    sysFlags;
 
        uint32_t                                    normalTaskQueueBias;
 
        bool                                        enableLeafReflectionReverseSubscription;
 
        bool                                        disableLoopDetection;
 
        uint32_t                                    maxSecurityLevel;
 
        RallypointServerRouteMap                    routeMap;
 
        RallypointServerStreamStatsExport           streamStatsExport;
 
        uint32_t                                    maxOutboundPeerConnectionIntervalDeltaSecs;
 
        int                                         peerRtTestIntervalMs;
 
        std::vector<RallypointRpRtTimingBehavior>   peerRtBehaviors;
 
        RallypointWebsocketSettings                 websocket;
 
        NsmConfiguration                            nsm;
 
        RallypointAdvertisingSettings               advertising;
 
        PacketCapturer                          rxCapture;
 
        PacketCapturer                          txCapture;
 
        std::string                             domainName;
 
        std::vector<std::string>                allowedDomains;
 
        std::vector<std::string>                blockedDomains;
 
        std::vector<std::string>                extraDomains;
 
        TuningSettings                          tuning; 
 
        std::vector<NamedIdentity>               additionalIdentities;
 
        RallypointServer()
        {
            clear();
        }
 
        void clear()
        {
            fipsCrypto.clear();
            watchdog.clear();
            id.clear();
            name.clear();
            listenPort = 7443;
            interfaceName.clear();
            certificate.clear();
            allowMulticastForwarding = false;
            peeringConfiguration.clear();
            peeringConfigurationFileName.clear();
            peeringConfigurationFileCommand.clear();
            peeringConfigurationFileCheckSecs = 60;
            ioPools = -1;
            statusReport.clear();
            limits.clear();
            linkGraph.clear();
            externalHealthCheckResponder.clear();
            allowPeerForwarding = false;
            multicastInterfaceName.clear();
            tls.clear();
            discovery.clear();
            forwardDiscoveredGroups = false;
            forwardMulticastAddressing = false;
            isMeshLeaf = false;
            disableMessageSigning = false;
            multicastRestrictions.clear();
            igmpSnooping.clear();
            staticReflectors.clear();
            tcpTxOptions.clear();
            multicastTxOptions.clear();
            certStoreFileName.clear();
            certStorePasswordHex.clear();
            groupRestrictions.clear();
            configurationCheckSignalName = "rts.7b392d1.${id}";
            licensing.clear();
            featureset.clear();
            udpStreaming.clear();
            sysFlags = 0;
            normalTaskQueueBias = 0;
            enableLeafReflectionReverseSubscription = false;
            disableLoopDetection = false;
            maxSecurityLevel = 0;
            routeMap.clear();
            streamStatsExport.clear();
            maxOutboundPeerConnectionIntervalDeltaSecs = 15;
            peerRtTestIntervalMs = 60000;
            peerRtBehaviors.clear();
            websocket.clear();
            nsm.clear();
            advertising.clear();
            extendedGroupRestrictions.clear();
            groupRestrictionAccessPolicyType = GroupRestrictionAccessPolicyType_t::graptPermissive;
            ipFamily = IpFamilyType_t::ifIp4;
            rxCapture.clear();
            txCapture.clear();
            domainName.clear();
            allowedDomains.clear();
            blockedDomains.clear();
            extraDomains.clear();
            tuning.clear();
            additionalIdentities.clear();
            streamIdPrivacyType = StreamIdPrivacyType_t::sptDefault;
        }
    };
 
    static void to_json(nlohmann::json& j, const RallypointServer& p)
    {
        j = nlohmann::json{            
            TOJSON_IMPL(fipsCrypto),
            TOJSON_IMPL(watchdog),
            TOJSON_IMPL(id),
            TOJSON_IMPL(name),
            TOJSON_IMPL(listenPort),
            TOJSON_IMPL(interfaceName),
            TOJSON_IMPL(certificate),
            TOJSON_IMPL(allowMulticastForwarding),
            // TOJSON_IMPL(peeringConfiguration),               // NOTE: Not serialized!
            TOJSON_IMPL(peeringConfigurationFileName),
            TOJSON_IMPL(peeringConfigurationFileCommand),
            TOJSON_IMPL(peeringConfigurationFileCheckSecs),
            TOJSON_IMPL(ioPools),
            TOJSON_IMPL(statusReport),
            TOJSON_IMPL(limits),
            TOJSON_IMPL(linkGraph),
            TOJSON_IMPL(externalHealthCheckResponder),
            TOJSON_IMPL(allowPeerForwarding),
            TOJSON_IMPL(multicastInterfaceName),
            TOJSON_IMPL(tls),
            TOJSON_IMPL(discovery),
            TOJSON_IMPL(forwardDiscoveredGroups),
            TOJSON_IMPL(forwardMulticastAddressing),
            TOJSON_IMPL(isMeshLeaf),
            TOJSON_IMPL(disableMessageSigning),
            TOJSON_IMPL(multicastRestrictions),
            TOJSON_IMPL(igmpSnooping),
            TOJSON_IMPL(staticReflectors),
            TOJSON_IMPL(tcpTxOptions),
            TOJSON_IMPL(multicastTxOptions),
            TOJSON_IMPL(certStoreFileName),
            TOJSON_IMPL(certStorePasswordHex),
            TOJSON_IMPL(groupRestrictions),
            TOJSON_IMPL(configurationCheckSignalName),
            TOJSON_IMPL(featureset),
            TOJSON_IMPL(licensing),
            TOJSON_IMPL(udpStreaming),
            TOJSON_IMPL(sysFlags),
            TOJSON_IMPL(normalTaskQueueBias),
            TOJSON_IMPL(enableLeafReflectionReverseSubscription),
            TOJSON_IMPL(disableLoopDetection),
            TOJSON_IMPL(maxSecurityLevel),
            TOJSON_IMPL(routeMap),
            TOJSON_IMPL(streamStatsExport),
            TOJSON_IMPL(maxOutboundPeerConnectionIntervalDeltaSecs),
            TOJSON_IMPL(peerRtTestIntervalMs),
            TOJSON_IMPL(peerRtBehaviors),
            TOJSON_IMPL(websocket),
            TOJSON_IMPL(nsm),
            TOJSON_IMPL(advertising),
            TOJSON_IMPL(extendedGroupRestrictions),
            TOJSON_IMPL(groupRestrictionAccessPolicyType),
            TOJSON_IMPL(ipFamily),
            TOJSON_IMPL(rxCapture),
            TOJSON_IMPL(txCapture),
            TOJSON_IMPL(domainName),
            TOJSON_IMPL(allowedDomains),
            TOJSON_IMPL(blockedDomains),
            TOJSON_IMPL(extraDomains),
            TOJSON_IMPL(tuning),
            TOJSON_IMPL(additionalIdentities),
            TOJSON_IMPL(streamIdPrivacyType)
        };
    }
    static void from_json(const nlohmann::json& j, RallypointServer& p)
    {
        p.clear();
        getOptional<FipsCryptoSettings>("fipsCrypto", p.fipsCrypto, j);
        getOptional<WatchdogSettings>("watchdog", p.watchdog, j);
        getOptional<std::string>("id", p.id, j);
        getOptional<std::string>("name", p.name, j);
        getOptional<SecurityCertificate>("certificate", p.certificate, j);
        getOptional<std::string>("interfaceName", p.interfaceName, j);
        getOptional<int>("listenPort", p.listenPort, j, 7443);
        getOptional<bool>("allowMulticastForwarding", p.allowMulticastForwarding, j, false);
        //getOptional<PeeringConfiguration>("peeringConfiguration", p.peeringConfiguration, j);         // NOTE: Not serialized!
        getOptional<std::string>("peeringConfigurationFileName", p.peeringConfigurationFileName, j);
        getOptional<std::string>("peeringConfigurationFileCommand", p.peeringConfigurationFileCommand, j);
        getOptional<int>("peeringConfigurationFileCheckSecs", p.peeringConfigurationFileCheckSecs, j, 60);
        getOptional<int>("ioPools", p.ioPools, j, -1);
        getOptional<RallypointServerStatusReportConfiguration>("statusReport", p.statusReport, j);
        getOptional<RallypointServerLimits>("limits", p.limits, j);
        getOptional<RallypointServerLinkGraph>("linkGraph", p.linkGraph, j);
        getOptional<ExternalHealthCheckResponder>("externalHealthCheckResponder", p.externalHealthCheckResponder, j);
        getOptional<bool>("allowPeerForwarding", p.allowPeerForwarding, j, false);
        getOptional<std::string>("multicastInterfaceName", p.multicastInterfaceName, j);
        getOptional<Tls>("tls", p.tls, j);
        getOptional<DiscoveryConfiguration>("discovery", p.discovery, j);        
        getOptional<bool>("forwardDiscoveredGroups", p.forwardDiscoveredGroups, j, false);
        getOptional<bool>("forwardMulticastAddressing", p.forwardMulticastAddressing, j, false);
        getOptional<bool>("isMeshLeaf", p.isMeshLeaf, j, false);
        getOptional<bool>("disableMessageSigning", p.disableMessageSigning, j, false);
        getOptional<NetworkAddressRestrictionList>("multicastRestrictions", p.multicastRestrictions, j);
        getOptional<IgmpSnooping>("igmpSnooping", p.igmpSnooping, j);
        getOptional<std::vector<RallypointReflector>>("staticReflectors", p.staticReflectors, j);
        getOptional<TcpNetworkTxOptions>("tcpTxOptions", p.tcpTxOptions, j);
        getOptional<NetworkTxOptions>("multicastTxOptions", p.multicastTxOptions, j);
        getOptional<std::string>("certStoreFileName", p.certStoreFileName, j);
        getOptional<std::string>("certStorePasswordHex", p.certStorePasswordHex, j);
        getOptional<StringRestrictionList>("groupRestrictions", p.groupRestrictions, j);
        getOptional<std::string>("configurationCheckSignalName", p.configurationCheckSignalName, j, "rts.7b392d1.${id}");
        getOptional<Licensing>("licensing", p.licensing, j);
        getOptional<Featureset>("featureset", p.featureset, j);
        getOptional<RallypointUdpStreaming>("udpStreaming", p.udpStreaming, j);
        getOptional<uint32_t>("sysFlags", p.sysFlags, j, 0);
        getOptional<uint32_t>("normalTaskQueueBias", p.normalTaskQueueBias, j, 0);
        getOptional<bool>("enableLeafReflectionReverseSubscription", p.enableLeafReflectionReverseSubscription, j, false);
        getOptional<bool>("disableLoopDetection", p.disableLoopDetection, j, false);
        getOptional<uint32_t>("maxSecurityLevel", p.maxSecurityLevel, j, 0);
        getOptional<RallypointServerRouteMap>("routeMap", p.routeMap, j);
        getOptional<RallypointServerStreamStatsExport>("streamStatsExport", p.streamStatsExport, j);
        getOptional<uint32_t>("maxOutboundPeerConnectionIntervalDeltaSecs", p.maxOutboundPeerConnectionIntervalDeltaSecs, j, 15);        
        getOptional<int>("peerRtTestIntervalMs", p.peerRtTestIntervalMs, j, 60000);
        getOptional<std::vector<RallypointRpRtTimingBehavior>>("peerRtBehaviors", p.peerRtBehaviors, j);
        getOptional<RallypointWebsocketSettings>("websocket", p.websocket, j);
        getOptional<NsmConfiguration>("nsm", p.nsm, j);
        getOptional<RallypointAdvertisingSettings>("advertising", p.advertising, j);
        getOptional<std::vector<RallypointExtendedGroupRestriction>>("extendedGroupRestrictions", p.extendedGroupRestrictions, j);        
        getOptional<GroupRestrictionAccessPolicyType_t>("groupRestrictionAccessPolicyType", p.groupRestrictionAccessPolicyType, j, GroupRestrictionAccessPolicyType_t::graptPermissive);
        getOptional<IpFamilyType_t>("ipFamily", p.ipFamily, j, IpFamilyType_t::ifIp4);
        getOptional<PacketCapturer>("rxCapture", p.rxCapture, j);
        getOptional<PacketCapturer>("txCapture", p.txCapture, j);
        getOptional<std::string>("domainName", p.domainName, j);
        getOptional<std::vector<std::string>>("allowedDomains", p.allowedDomains, j);
        getOptional<std::vector<std::string>>("blockedDomains", p.blockedDomains, j);
        getOptional<std::vector<std::string>>("extraDomains", p.extraDomains, j);
        getOptional<TuningSettings>("tuning", p.tuning, j);
        getOptional<std::vector<NamedIdentity>>("additionalIdentities", p.additionalIdentities, j);
        getOptional<RallypointServer::StreamIdPrivacyType_t>("streamIdPrivacyType", p.streamIdPrivacyType, j, RallypointServer::StreamIdPrivacyType_t::sptDefault);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(NsmNodeScripts)
    class NsmNodeScripts : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(NsmNodeScripts)
 
    public:
        std::string                     onIdle;
        std::string                     beforeGoingActive;
        std::string                     onGoingActive;
        std::string                     beforeActive;
        std::string                     onActive;
        std::string                     inDashboard;
        std::string                     onStatusReport;
 
        NsmNodeScripts()
        {
            clear();
        }
 
        void clear()
        {
            onIdle.clear();
            beforeGoingActive.clear();
            onGoingActive.clear();
            beforeActive.clear();
            onActive.clear();
            inDashboard.clear();
            onStatusReport.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const NsmNodeScripts& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(onIdle),
            TOJSON_IMPL(beforeGoingActive),
            TOJSON_IMPL(onGoingActive),
            TOJSON_IMPL(beforeActive),
            TOJSON_IMPL(onActive),
            TOJSON_IMPL(inDashboard),
            TOJSON_IMPL(onStatusReport)
        };
    }
    static void from_json(const nlohmann::json& j, NsmNodeScripts& p)
    {
        p.clear();
        getOptional<std::string>("onIdle", p.onIdle, j);
        getOptional<std::string>("beforeGoingActive", p.beforeGoingActive, j);
        getOptional<std::string>("onGoingActive", p.onGoingActive, j);
        getOptional<std::string>("beforeActive", p.beforeActive, j);
        getOptional<std::string>("onActive", p.onActive, j);
        getOptional<std::string>("inDashboard", p.inDashboard, j);
        getOptional<std::string>("onStatusReport", p.onStatusReport, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(NsmNodeLogging)
    class NsmNodeLogging : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(NsmNodeLogging)
 
    public:
        int                             level;
        bool                            dashboard;
        bool                            logCommandOutput;
        bool                            logResourceStates;
 
        NsmNodeLogging()
        {
            clear();
        }
 
        void clear()
        {
            level = 3;
            dashboard = false;
            logCommandOutput = false;
            logResourceStates = false;
        }
    };
 
    static void to_json(nlohmann::json& j, const NsmNodeLogging& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(level),
            TOJSON_IMPL(dashboard),
            TOJSON_IMPL(logCommandOutput),
            TOJSON_IMPL(logResourceStates)
        };
    }
    static void from_json(const nlohmann::json& j, NsmNodeLogging& p)
    {
        p.clear();
        getOptional<int>("level", p.level, j, 3);
        getOptional<bool>("dashboard", p.dashboard, j, false);
        getOptional<bool>("logCommandOutput", p.logCommandOutput, j, false);
        getOptional<bool>("logResourceStates", p.logResourceStates, j, false);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(NsmNodePeriodic)
    class NsmNodePeriodic : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(NsmNodePeriodic)
 
    public:
        std::string                     id;
        int                             intervalSecs;
        std::string                     command;
 
        NsmNodePeriodic()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            intervalSecs = 1;
            command.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const NsmNodePeriodic& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(intervalSecs),
            TOJSON_IMPL(command)
        };
    }
    static void from_json(const nlohmann::json& j, NsmNodePeriodic& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j);
        getOptional<int>("intervalSecs", p.intervalSecs, j, 1);
        getOptional<std::string>("command", p.command, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(NsmNodeCotSettings)
    class NsmNodeCotSettings : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(NsmNodeCotSettings)
 
    public:
        bool                            useCot;
        std::string                     uid;
        std::string                     type;
        std::string                     how;
        std::string                     lat;
        std::string                     lon;
        std::string                     ce;
        std::string                     hae;
        std::string                     le;
        std::string                     detailJson;
 
        NsmNodeCotSettings()
        {
            clear();
        }
 
        void clear()
        {
            useCot = false;
            uid.clear();
            type.clear();
            how.clear();
            lat.clear();
            lon.clear();
            ce.clear();
            hae.clear();
            le.clear();
            detailJson.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const NsmNodeCotSettings& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(useCot),
            TOJSON_IMPL(uid),
            TOJSON_IMPL(type),
            TOJSON_IMPL(how),
            TOJSON_IMPL(lat),
            TOJSON_IMPL(lon),
            TOJSON_IMPL(ce),
            TOJSON_IMPL(hae),
            TOJSON_IMPL(le),
            TOJSON_IMPL(detailJson)
        };
    }
    static void from_json(const nlohmann::json& j, NsmNodeCotSettings& p)
    {
        p.clear();
        getOptional<bool>("useCot", p.useCot, j, false);
        getOptional<std::string>("uid", p.uid, j);
        getOptional<std::string>("type", p.type, j);
        getOptional<std::string>("how", p.how, j);
        getOptional<std::string>("lat", p.lat, j);
        getOptional<std::string>("lon", p.lon, j);
        getOptional<std::string>("ce", p.ce, j);
        getOptional<std::string>("hae", p.hae, j);
        getOptional<std::string>("le", p.le, j);
        getOptional<std::string>("detailJson", p.detailJson, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(NsmNodeStatusReportConfiguration)
    class NsmNodeStatusReportConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(NsmNodeStatusReportConfiguration)
 
    public:
        std::string                     fileName;
 
        int                             intervalSecs;
 
        bool                            enabled;
 
        std::string                     runCmd;
 
        bool                            includeResourceDetail;
 
        NsmNodeStatusReportConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            fileName.clear();
            intervalSecs = 60;
            enabled = false;
            includeResourceDetail = false;
            runCmd.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const NsmNodeStatusReportConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(fileName),
            TOJSON_IMPL(intervalSecs),
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(includeResourceDetail),
            TOJSON_IMPL(runCmd)
        };
    }
    static void from_json(const nlohmann::json& j, NsmNodeStatusReportConfiguration& p)
    {
        p.clear();
        getOptional<std::string>("fileName", p.fileName, j);
        getOptional<int>("intervalSecs", p.intervalSecs, j, 60);
        getOptional<bool>("enabled", p.enabled, j, false);
        getOptional<std::string>("runCmd", p.runCmd, j);
        getOptional<bool>("includeResourceDetail", p.includeResourceDetail, j, false);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(NsmNode)
    class NsmNode : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(NsmNode)
 
    public:        
 
        FipsCryptoSettings                          fipsCrypto;
 
        WatchdogSettings                            watchdog;
 
        std::string                                 id;
 
        std::string                                 name;
 
        std::string                                 domainName;
 
        IpFamilyType_t                              ipFamily;
 
        std::string                                 multicastInterfaceName;
 
        NsmConfiguration                            stateMachine;
 
        int                                         defaultPriority;
 
        int                                         fixedToken;
 
        bool                                        dashboardToken;
 
        NsmNodeScripts                              scripts;
 
        NsmNodeLogging                              logging;
 
        NsmNodeCotSettings                          cot;
 
        std::vector<NsmNodePeriodic>                periodics;
 
        NsmNodeStatusReportConfiguration            statusReport;
 
        std::string                                 configurationCheckSignalName;
 
        Licensing                                   licensing;
 
        Featureset                                  featureset;
 
        PacketCapturer                              rxCapture;
 
        PacketCapturer                              txCapture;
 
        TuningSettings                              tuning; 
 
        NsmNode()
        {
            clear();
        }
 
        void clear()
        {
            fipsCrypto.clear();
            watchdog.clear();
            id.clear();
            name.clear();
            domainName.clear();
            multicastInterfaceName.clear();
            stateMachine.clear();
            defaultPriority = 0;
            fixedToken = -1;
            dashboardToken = false;
            scripts.clear();
            logging.clear();
            cot.clear();
            periodics.clear();
            statusReport.clear();
            configurationCheckSignalName = "rts.7b392d1.${id}";
            licensing.clear();
            featureset.clear();
            rxCapture.clear();
            txCapture.clear();
            tuning.clear();
            ipFamily = IpFamilyType_t::ifIp4;
        }
    };
 
    static void to_json(nlohmann::json& j, const NsmNode& p)
    {
        j = nlohmann::json{            
            TOJSON_IMPL(fipsCrypto),
            TOJSON_IMPL(watchdog),
            TOJSON_IMPL(id),
            TOJSON_IMPL(name),
            TOJSON_IMPL(domainName),
            TOJSON_IMPL(multicastInterfaceName),
            TOJSON_IMPL(stateMachine),
            TOJSON_IMPL(defaultPriority),
            TOJSON_IMPL(fixedToken),
            TOJSON_IMPL(dashboardToken),
            TOJSON_IMPL(scripts),
            TOJSON_IMPL(logging),
            TOJSON_IMPL(cot),
            TOJSON_IMPL(periodics),
            TOJSON_IMPL(statusReport),
            TOJSON_IMPL(configurationCheckSignalName),
            TOJSON_IMPL(featureset),
            TOJSON_IMPL(licensing),
            TOJSON_IMPL(ipFamily),
            TOJSON_IMPL(rxCapture),
            TOJSON_IMPL(txCapture),
            TOJSON_IMPL(tuning)
        };
    }
    static void from_json(const nlohmann::json& j, NsmNode& p)
    {
        p.clear();
        getOptional<FipsCryptoSettings>("fipsCrypto", p.fipsCrypto, j);
        getOptional<WatchdogSettings>("watchdog", p.watchdog, j);
        getOptional<std::string>("id", p.id, j);
        getOptional<std::string>("name", p.name, j);
        getOptional<std::string>("domainName", p.domainName, j);
        getOptional<std::string>("multicastInterfaceName", p.multicastInterfaceName, j);
        getOptional<NsmConfiguration>("stateMachine", p.stateMachine, j);
        getOptional<int>("defaultPriority", p.defaultPriority, j, 0);
        getOptional<int>("fixedToken", p.fixedToken, j, -1);
        getOptional<bool>("dashboardToken", p.dashboardToken, j, false);
        getOptional<NsmNodeScripts>("scripts", p.scripts, j);
        getOptional<NsmNodeLogging>("logging", p.logging, j);
        getOptional<NsmNodeCotSettings>("cot", p.cot, j);
        getOptional<std::vector<NsmNodePeriodic>>("periodics", p.periodics, j);
        getOptional<NsmNodeStatusReportConfiguration>("statusReport", p.statusReport, j);
        getOptional<std::string>("configurationCheckSignalName", p.configurationCheckSignalName, j, "rts.7b392d1.${id}");
        getOptional<Licensing>("licensing", p.licensing, j);
        getOptional<Featureset>("featureset", p.featureset, j);
        getOptional<PacketCapturer>("rxCapture", p.rxCapture, j);
        getOptional<PacketCapturer>("txCapture", p.txCapture, j);
        getOptional<TuningSettings>("tuning", p.tuning, j);
        getOptional<IpFamilyType_t>("ipFamily", p.ipFamily, j, IpFamilyType_t::ifIp4);
    }    
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(PlatformDiscoveredService)
    class PlatformDiscoveredService : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(PlatformDiscoveredService)
 
    public:
 
        std::string                             id;
 
        std::string                             type;
 
        std::string                             name;
 
        NetworkAddress                          address;
 
        std::string                             uri;
 
        uint32_t                                configurationVersion;
 
        PlatformDiscoveredService()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            type.clear();
            name.clear();
            address.clear();
            uri.clear();
            configurationVersion = 0;
        }
    };
 
    static void to_json(nlohmann::json& j, const PlatformDiscoveredService& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(type),
            TOJSON_IMPL(name),
            TOJSON_IMPL(address),
            TOJSON_IMPL(uri),
            TOJSON_IMPL(configurationVersion)
        };
    }
    static void from_json(const nlohmann::json& j, PlatformDiscoveredService& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j);
        getOptional<std::string>("type", p.type, j);
        getOptional<std::string>("name", p.name, j);
        getOptional<NetworkAddress>("address", p.address, j);
        getOptional<std::string>("uri", p.uri, j);
        getOptional<uint32_t>("configurationVersion", p.configurationVersion, j, 0);
    }
 
 
    //-----------------------------------------------------------
    class TimelineEvent
    {
    public:
        typedef enum
        {
            etUndefined           = 0,
            etAudio               = 1,
            etLocation            = 2,
            etUser                = 3
        } EventType_t;
 
        typedef enum
        {
            dNone        = 0,
            dInbound     = 1,
            dOutbound    = 2,
            dBoth        = 3,
            dUndefined   = 4,
        } Direction_t;
    };
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(TimelineQueryParameters)
    class TimelineQueryParameters : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(TimelineQueryParameters)
 
    public:
 
        long                    maxCount;
 
        bool                    mostRecentFirst;
 
        uint64_t                startedOnOrAfter;
 
        uint64_t                endedOnOrBefore;
 
        int                     onlyDirection;
 
        int                     onlyType;
 
        bool                    onlyCommitted;
 
        std::string             onlyAlias;
 
        std::string             onlyNodeId;
 
        int                     onlyTxId;
 
        std::string             sql;
 
        TimelineQueryParameters()
        {
            clear();
        }
 
        void clear()
        {
            maxCount = 50;
            mostRecentFirst = true;
            startedOnOrAfter = 0;
            endedOnOrBefore = 0;
            onlyDirection = 0;
            onlyType = 0;
            onlyCommitted = true;
            onlyAlias.clear();
            onlyNodeId.clear();
            sql.clear();
            onlyTxId = 0;
        }
    };
 
    static void to_json(nlohmann::json& j, const TimelineQueryParameters& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(maxCount),
            TOJSON_IMPL(mostRecentFirst),
            TOJSON_IMPL(startedOnOrAfter),
            TOJSON_IMPL(endedOnOrBefore),
            TOJSON_IMPL(onlyDirection),
            TOJSON_IMPL(onlyType),
            TOJSON_IMPL(onlyCommitted),
            TOJSON_IMPL(onlyAlias),
            TOJSON_IMPL(onlyNodeId),
            TOJSON_IMPL(onlyTxId),
            TOJSON_IMPL(sql)
        };
    }
    static void from_json(const nlohmann::json& j, TimelineQueryParameters& p)
    {
        p.clear();
        getOptional<long>("maxCount", p.maxCount, j, 50);
        getOptional<bool>("mostRecentFirst", p.mostRecentFirst, j, false);
        getOptional<uint64_t>("startedOnOrAfter", p.startedOnOrAfter, j, 0);
        getOptional<uint64_t>("endedOnOrBefore", p.endedOnOrBefore, j, 0);
        getOptional<int>("onlyDirection", p.onlyDirection, j, 0);
        getOptional<int>("onlyType", p.onlyType, j, 0);
        getOptional<bool>("onlyCommitted", p.onlyCommitted, j, true);
        getOptional<std::string>("onlyAlias", p.onlyAlias, j, EMPTY_STRING);
        getOptional<std::string>("onlyNodeId", p.onlyNodeId, j, EMPTY_STRING);
        getOptional<int>("onlyTxId", p.onlyTxId, j, 0);
        getOptional<std::string>("sql", p.sql, j, EMPTY_STRING);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(CertStoreCertificate)
    class CertStoreCertificate : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(CertStoreCertificate)
 
    public:
        std::string                     id;
 
        std::string                     certificatePem;
 
        std::string                     privateKeyPem;
 
        void                            *internalData;
 
        std::string                     tags;
        
        CertStoreCertificate()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            certificatePem.clear();
            privateKeyPem.clear();
            internalData = nullptr;
            tags.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const CertStoreCertificate& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(certificatePem),
            TOJSON_IMPL(privateKeyPem),
            TOJSON_IMPL(tags)
        };
    }
    static void from_json(const nlohmann::json& j, CertStoreCertificate& p)
    {
        p.clear();
        j.at("id").get_to(p.id);
        j.at("certificatePem").get_to(p.certificatePem);
        getOptional<std::string>("privateKeyPem", p.privateKeyPem, j, EMPTY_STRING);
        getOptional<std::string>("tags", p.tags, j, EMPTY_STRING);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(CertStore)
    class CertStore : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(CertStore)
 
    public:
        std::string                         id;
 
        std::vector<CertStoreCertificate>    certificates;
 
        std::vector<KvPair>                  kvp;
 
        CertStore()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            certificates.clear();
            kvp.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const CertStore& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(certificates),
            TOJSON_IMPL(kvp)
        };
    }
    static void from_json(const nlohmann::json& j, CertStore& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j, EMPTY_STRING);
        getOptional<std::vector<CertStoreCertificate>>("certificates", p.certificates, j);
        getOptional<std::vector<KvPair>>("kvp", p.kvp, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(CertStoreCertificateElement)
    class CertStoreCertificateElement : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(CertStoreCertificateElement)
 
    public:
        std::string                     id;
 
        bool                            hasPrivateKey;
 
        std::string                     certificatePem;
 
        std::string                     tags;
 
        CertStoreCertificateElement()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            hasPrivateKey = false;
            tags.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const CertStoreCertificateElement& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(hasPrivateKey),
            TOJSON_IMPL(tags)
        };
 
        if(!p.certificatePem.empty())
        {
            j["certificatePem"] = p.certificatePem;            
        }
    }
    static void from_json(const nlohmann::json& j, CertStoreCertificateElement& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j, EMPTY_STRING);
        getOptional<bool>("hasPrivateKey", p.hasPrivateKey, j, false);
        getOptional<std::string>("certificatePem", p.certificatePem, j, EMPTY_STRING);
        getOptional<std::string>("tags", p.tags, j, EMPTY_STRING);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(CertStoreDescriptor)
    class CertStoreDescriptor : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(CertStoreDescriptor)
 
    public:
        std::string                                     id;
 
        std::string                                     fileName;
 
        int                                             version;
 
        int                                             flags;
 
        std::vector<CertStoreCertificateElement>        certificates;
 
        std::vector<KvPair>                             kvp;
 
        CertStoreDescriptor()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            fileName.clear();
            version = 0;
            flags = 0;
            certificates.clear();
            kvp.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const CertStoreDescriptor& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(fileName),
            TOJSON_IMPL(version),
            TOJSON_IMPL(flags),
            TOJSON_IMPL(certificates),
            TOJSON_IMPL(kvp)
        };
    }
    static void from_json(const nlohmann::json& j, CertStoreDescriptor& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j, EMPTY_STRING);
        getOptional<std::string>("fileName", p.fileName, j, EMPTY_STRING);
        getOptional<int>("version", p.version, j, 0);
        getOptional<int>("flags", p.flags, j, 0);
        getOptional<std::vector<CertStoreCertificateElement>>("certificates", p.certificates, j);
        getOptional<std::vector<KvPair>>("kvp", p.kvp, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(CertificateSubjectElement)
    class CertificateSubjectElement : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(CertificateSubjectElement)
 
    public:
        std::string                                     name;
 
        std::string                                     value;
 
        CertificateSubjectElement()
        {
            clear();
        }
 
        void clear()
        {
            name.clear();
            value.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const CertificateSubjectElement& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(name),
            TOJSON_IMPL(value)
        };
    }
    static void from_json(const nlohmann::json& j, CertificateSubjectElement& p)
    {
        p.clear();
        getOptional<std::string>("name", p.name, j, EMPTY_STRING);
        getOptional<std::string>("value", p.value, j, EMPTY_STRING);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(CertificateDescriptor)
    class CertificateDescriptor : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(CertificateDescriptor)
 
    public:
        std::string                                     subject;
 
        std::string                                     issuer;
 
        bool                                            selfSigned;
 
        int                                             version;
 
        std::string                                     notBefore;
 
        std::string                                     notAfter;
 
        std::string                                     serial;
 
        std::string                                     fingerprint;
 
        std::vector<CertificateSubjectElement>          subjectElements;
 
        std::vector<CertificateSubjectElement>          issuerElements;        
 
        std::string                                     certificatePem;
 
        std::string                                     publicKeyPem;
 
        CertificateDescriptor()
        {
            clear();
        }
 
        void clear()
        {
            subject.clear();
            issuer.clear();
            selfSigned = false;
            version = 0;
            notBefore.clear();
            notAfter.clear();
            serial.clear();
            fingerprint.clear();
            subjectElements.clear();
            issuerElements.clear();
            certificatePem.clear();
            publicKeyPem.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const CertificateDescriptor& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(subject),
            TOJSON_IMPL(issuer),
            TOJSON_IMPL(selfSigned),
            TOJSON_IMPL(version),
            TOJSON_IMPL(notBefore),
            TOJSON_IMPL(notAfter),
            TOJSON_IMPL(serial),
            TOJSON_IMPL(fingerprint),
            TOJSON_IMPL(subjectElements),
            TOJSON_IMPL(issuerElements),
            TOJSON_IMPL(certificatePem),
            TOJSON_IMPL(publicKeyPem)
        };
    }
    static void from_json(const nlohmann::json& j, CertificateDescriptor& p)
    {
        p.clear();
        getOptional<std::string>("subject", p.subject, j, EMPTY_STRING);
        getOptional<std::string>("issuer", p.issuer, j, EMPTY_STRING);
        getOptional<bool>("selfSigned", p.selfSigned, j, false);
        getOptional<int>("version", p.version, j, 0);
        getOptional<std::string>("notBefore", p.notBefore, j, EMPTY_STRING);
        getOptional<std::string>("notAfter", p.notAfter, j, EMPTY_STRING);
        getOptional<std::string>("serial", p.serial, j, EMPTY_STRING);
        getOptional<std::string>("fingerprint", p.fingerprint, j, EMPTY_STRING);
        getOptional<std::string>("certificatePem", p.certificatePem, j, EMPTY_STRING);
        getOptional<std::string>("publicKeyPem", p.publicKeyPem, j, EMPTY_STRING);
        getOptional<std::vector<CertificateSubjectElement>>("subjectElements", p.subjectElements, j);
        getOptional<std::vector<CertificateSubjectElement>>("issuerElements", p.issuerElements, j);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RiffDescriptor)
    class RiffDescriptor : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(RiffDescriptor)
 
    public:
        std::string                             file;
 
        bool                                    verified;
 
        int                                     channels;
 
        int                                     sampleCount;
 
        std::string                             meta;
 
        std::string                             certPem;
 
        CertificateDescriptor                   certDescriptor;
 
        std::string                             signature;
 
        RiffDescriptor()
        {
            clear();
        }
 
        void clear()
        {
            file.clear();
            verified = false;
            channels = 0;
            sampleCount = 0;
            meta.clear();
            certPem.clear();
            certDescriptor.clear();
            signature.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const RiffDescriptor& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(file),
            TOJSON_IMPL(verified),
            TOJSON_IMPL(channels),
            TOJSON_IMPL(sampleCount),
            TOJSON_IMPL(meta),
            TOJSON_IMPL(certPem),
            TOJSON_IMPL(certDescriptor),
            TOJSON_IMPL(signature)
        };
    }
 
    static void from_json(const nlohmann::json& j, RiffDescriptor& p)
    {
        p.clear();
        FROMJSON_IMPL(file, std::string, EMPTY_STRING);
        FROMJSON_IMPL(verified, bool, false);
        FROMJSON_IMPL(channels, int, 0);
        FROMJSON_IMPL(sampleCount, int, 0);
        FROMJSON_IMPL(meta, std::string, EMPTY_STRING);
        FROMJSON_IMPL(certPem, std::string, EMPTY_STRING);
        getOptional<CertificateDescriptor>("certDescriptor", p.certDescriptor, j);
        FROMJSON_IMPL(signature, std::string, EMPTY_STRING);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(BridgeCreationDetail)
    class BridgeCreationDetail : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_WRAPPED_JSON_SERIALIZATION(BridgeCreationDetail)
        IMPLEMENT_JSON_DOCUMENTATION(BridgeCreationDetail)
 
    public:
        typedef enum
        {
            csUndefined                         = 0,
 
            csOk                                = 1,
 
            csNoJson                            = -1,
 
            csAlreadyExists                     = -3,
 
            csInvalidConfiguration              = -4,
 
            csInvalidJson                       = -5,
 
            csInsufficientGroups                = -6,
 
            csTooManyGroups                     = -7,
 
            csDuplicateGroup                    = -8,
 
            csLocalLoopDetected                 = -9,
        } CreationStatus_t;
 
        std::string                                     id;
 
        CreationStatus_t                                status;
 
        BridgeCreationDetail()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            status = csUndefined;
        }
    };
 
    static void to_json(nlohmann::json& j, const BridgeCreationDetail& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(status)
        };
    }
    static void from_json(const nlohmann::json& j, BridgeCreationDetail& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j, EMPTY_STRING);
        getOptional<BridgeCreationDetail::CreationStatus_t>("status", p.status, j, BridgeCreationDetail::CreationStatus_t::csUndefined);
    }
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(GroupConnectionDetail)
    class GroupConnectionDetail : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_WRAPPED_JSON_SERIALIZATION(GroupConnectionDetail)
        IMPLEMENT_JSON_DOCUMENTATION(GroupConnectionDetail)
 
    public:
        typedef enum
        {
            ctUndefined                     = 0,
 
            ctDirectDatagram                = 1,
 
            ctRallypoint                    = 2
        } ConnectionType_t;
 
        std::string                                     id;
 
        ConnectionType_t                                connectionType;
 
        std::string                                     peer;
 
        bool                                            asFailover;
 
        std::string                                     reason;
 
        GroupConnectionDetail()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            connectionType = ctUndefined;
            peer.clear();
            asFailover = false;
            reason.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const GroupConnectionDetail& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(connectionType),
            TOJSON_IMPL(peer),
            TOJSON_IMPL(asFailover),
            TOJSON_IMPL(reason)
        };
 
        if(p.asFailover)
        {
            j["asFailover"] = p.asFailover;
        }
    }
    static void from_json(const nlohmann::json& j, GroupConnectionDetail& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j, EMPTY_STRING);
        getOptional<GroupConnectionDetail::ConnectionType_t>("connectionType", p.connectionType, j, GroupConnectionDetail::ConnectionType_t::ctUndefined);
        getOptional<std::string>("peer", p.peer, j, EMPTY_STRING);
        getOptional<bool>("asFailover", p.asFailover, j, false);
        getOptional<std::string>("reason", p.reason, j, EMPTY_STRING);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(GroupTxDetail)
    class GroupTxDetail : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_WRAPPED_JSON_SERIALIZATION(GroupTxDetail)
        IMPLEMENT_JSON_DOCUMENTATION(GroupTxDetail)
 
    public:
        typedef enum
        {
            txsUndefined                    = 0,
 
            txsTxStarted                    = 1,
 
            txsTxEnded                      = 2,
 
            txsNotAnAudioGroup              = -1,
 
            txsNotJoined                    = -2,
 
            txsNotConnected                 = -3,
 
            txsAlreadyTransmitting          = -4,
 
            txsInvalidParams                = -5,
 
            txsPriorityTooLow               = -6,
 
            txsRxActiveOnNonFdx             = -7,
 
            txsCannotSubscribeToInput       = -8,
 
            txsInvalidId                    = -9,
 
            txsTxEndedWithFailure           = -10,
 
            txsBridgedButNotMultistream     = -11,
 
            txsAutoEndedDueToNonMultistreamBridge     = -12,
 
            txsReBeginWithoutPriorBegin     = -13        
        } TxStatus_t;
 
        std::string                                     id;
 
        TxStatus_t                                      status;
 
        int                                             localPriority;
 
        int                                             remotePriority;
 
        long                                            nonFdxMsHangRemaining;
 
        uint32_t                                        txId;
 
        GroupTxDetail()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            status = txsUndefined;
            localPriority = 0;
            remotePriority = 0;
            nonFdxMsHangRemaining = 0;
            txId = 0;
        }
    };
 
    static void to_json(nlohmann::json& j, const GroupTxDetail& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(status),
            TOJSON_IMPL(localPriority),
            TOJSON_IMPL(txId)
        };
 
        // Include remote priority if status is related to that
        if(p.status == GroupTxDetail::TxStatus_t::txsPriorityTooLow)
        {
            j["remotePriority"] = p.remotePriority;
        }
        else if(p.status == GroupTxDetail::TxStatus_t::txsRxActiveOnNonFdx)
        {
            j["nonFdxMsHangRemaining"] = p.nonFdxMsHangRemaining;
        }
    }
    static void from_json(const nlohmann::json& j, GroupTxDetail& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j, EMPTY_STRING);
        getOptional<GroupTxDetail::TxStatus_t>("status", p.status, j, GroupTxDetail::TxStatus_t::txsUndefined);
        getOptional<int>("localPriority", p.localPriority, j, 0);
        getOptional<int>("remotePriority", p.remotePriority, j, 0);
        getOptional<long>("nonFdxMsHangRemaining", p.nonFdxMsHangRemaining, j, 0);
        getOptional<uint32_t>("txId", p.txId, j, 0);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(GroupCreationDetail)
    class GroupCreationDetail : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_WRAPPED_JSON_SERIALIZATION(GroupCreationDetail)
        IMPLEMENT_JSON_DOCUMENTATION(GroupCreationDetail)
 
    public:
        typedef enum
        {
            csUndefined                         = 0,
 
            csOk                                = 1,
 
            csNoJson                            = -1,
 
            csConflictingRpListAndCluster       = -2,
 
            csAlreadyExists                     = -3,
 
            csInvalidConfiguration              = -4,
 
            csInvalidJson                       = -5,
 
            csCryptoFailure                     = -6,
 
            csAudioInputFailure                 = -7,
 
            csAudioOutputFailure                = -8,
 
            csUnsupportedAudioEncoder          = -9,
 
            csNoLicense                         = -10,
 
            csInvalidTransport                  = -11,
 
            csAudioInputDeviceNotFound          = -12,
 
            csAudioOutputDeviceNotFound         = -13
        } CreationStatus_t;
 
        std::string                                     id;
 
        CreationStatus_t                                status;
 
        GroupCreationDetail()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            status = csUndefined;
        }
    };
 
    static void to_json(nlohmann::json& j, const GroupCreationDetail& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(status)
        };
    }
    static void from_json(const nlohmann::json& j, GroupCreationDetail& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j, EMPTY_STRING);
        getOptional<GroupCreationDetail::CreationStatus_t>("status", p.status, j, GroupCreationDetail::CreationStatus_t::csUndefined);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(GroupReconfigurationDetail)
    class GroupReconfigurationDetail : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_WRAPPED_JSON_SERIALIZATION(GroupReconfigurationDetail)
        IMPLEMENT_JSON_DOCUMENTATION(GroupReconfigurationDetail)
 
    public:
        typedef enum
        {
            rsUndefined                         = 0,
 
            rsOk                                = 1,
 
            rsNoJson                            = -1,
 
            rsInvalidConfiguration              = -2,
 
            rsInvalidJson                       = -3,
 
            rsAudioInputFailure                 = -4,
 
            rsAudioOutputFailure                = -5,
 
            rsDoesNotExist                      = -6,
 
            rsAudioInputInUse                   = -7,
 
            rsAudioDisabledForGroup             = -8,
 
            rsGroupIsNotAudio                   = -9
        } ReconfigurationStatus_t;
 
        std::string                                     id;
 
        ReconfigurationStatus_t                         status;
 
        GroupReconfigurationDetail()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            status = rsUndefined;
        }
    };
 
    static void to_json(nlohmann::json& j, const GroupReconfigurationDetail& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(status)
        };
    }
    static void from_json(const nlohmann::json& j, GroupReconfigurationDetail& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j, EMPTY_STRING);
        getOptional<GroupReconfigurationDetail::ReconfigurationStatus_t>("status", p.status, j, GroupReconfigurationDetail::ReconfigurationStatus_t::rsUndefined);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(GroupHealthReport)
    class GroupHealthReport : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_WRAPPED_JSON_SERIALIZATION(GroupHealthReport)
        IMPLEMENT_JSON_DOCUMENTATION(GroupHealthReport)
 
    public:
        std::string id;
        uint64_t    lastErrorTs;
        uint64_t    decryptionErrors;
        uint64_t    encryptionErrors;
        uint64_t    unsupportDecoderErrors;
        uint64_t    decoderFailures;
        uint64_t    decoderStartFailures;
        uint64_t    inboundRtpPacketAllocationFailures;
        uint64_t    inboundRtpPacketLoadFailures;
        uint64_t    latePacketsDiscarded;
        uint64_t    jitterBufferInsertionFailures;
        uint64_t    presenceDeserializationFailures;
        uint64_t    notRtpErrors;
        uint64_t    generalErrors;
        uint64_t    inboundRtpProcessorAllocationFailures;
        
        GroupHealthReport()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            lastErrorTs = 0;
            decryptionErrors = 0;
            encryptionErrors = 0;
            unsupportDecoderErrors = 0;
            decoderFailures = 0;
            decoderStartFailures = 0;
            inboundRtpPacketAllocationFailures = 0;
            inboundRtpPacketLoadFailures = 0;
            latePacketsDiscarded = 0;
            jitterBufferInsertionFailures = 0;
            presenceDeserializationFailures = 0;
            notRtpErrors = 0;
            generalErrors = 0;
            inboundRtpProcessorAllocationFailures = 0;
        }
    };
 
    static void to_json(nlohmann::json& j, const GroupHealthReport& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(lastErrorTs),
            TOJSON_IMPL(decryptionErrors),
            TOJSON_IMPL(encryptionErrors),
            TOJSON_IMPL(unsupportDecoderErrors),
            TOJSON_IMPL(decoderFailures),
            TOJSON_IMPL(decoderStartFailures),
            TOJSON_IMPL(inboundRtpPacketAllocationFailures),
            TOJSON_IMPL(inboundRtpPacketLoadFailures),
            TOJSON_IMPL(latePacketsDiscarded),
            TOJSON_IMPL(jitterBufferInsertionFailures),
            TOJSON_IMPL(presenceDeserializationFailures),
            TOJSON_IMPL(notRtpErrors),
            TOJSON_IMPL(generalErrors),
            TOJSON_IMPL(inboundRtpProcessorAllocationFailures)
        };
    }
    static void from_json(const nlohmann::json& j, GroupHealthReport& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j, EMPTY_STRING);
        getOptional<uint64_t>("lastErrorTs", p.lastErrorTs, j, 0);
        getOptional<uint64_t>("decryptionErrors", p.decryptionErrors, j, 0);
        getOptional<uint64_t>("encryptionErrors", p.encryptionErrors, j, 0);
        getOptional<uint64_t>("unsupportDecoderErrors", p.unsupportDecoderErrors, j, 0);
        getOptional<uint64_t>("decoderFailures", p.decoderFailures, j, 0);
        getOptional<uint64_t>("decoderStartFailures", p.decoderStartFailures, j, 0);
        getOptional<uint64_t>("inboundRtpPacketAllocationFailures", p.inboundRtpPacketAllocationFailures, j, 0);
        getOptional<uint64_t>("inboundRtpPacketLoadFailures", p.inboundRtpPacketLoadFailures, j, 0);
        getOptional<uint64_t>("latePacketsDiscarded", p.latePacketsDiscarded, j, 0);
        getOptional<uint64_t>("jitterBufferInsertionFailures", p.jitterBufferInsertionFailures, j, 0);
        getOptional<uint64_t>("presenceDeserializationFailures", p.presenceDeserializationFailures, j, 0);
        getOptional<uint64_t>("notRtpErrors", p.notRtpErrors, j, 0);
        getOptional<uint64_t>("generalErrors", p.generalErrors, j, 0);
        getOptional<uint64_t>("inboundRtpProcessorAllocationFailures", p.inboundRtpProcessorAllocationFailures, j, 0);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(InboundProcessorStats)
    class InboundProcessorStats : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_WRAPPED_JSON_SERIALIZATION(InboundProcessorStats)
        IMPLEMENT_JSON_DOCUMENTATION(InboundProcessorStats)
 
    public:
        uint32_t                    ssrc;
        double                      jitter;
        uint64_t                    minRtpSamplesInQueue;
        uint64_t                    maxRtpSamplesInQueue;
        uint64_t                    totalSamplesTrimmed;
        uint64_t                    underruns;
        uint64_t                    overruns;
        uint64_t                    samplesInQueue;
        uint64_t                    totalPacketsReceived;
        uint64_t                    totalPacketsLost;
        uint64_t                    totalPacketsDiscarded;
 
        InboundProcessorStats()
        {
            clear();
        }
 
        void clear()
        {
            ssrc = 0;
            jitter = 0.0;
            minRtpSamplesInQueue = 0;
            maxRtpSamplesInQueue = 0;
            totalSamplesTrimmed = 0;
            underruns = 0;
            overruns = 0;
            samplesInQueue = 0;
            totalPacketsReceived = 0;
            totalPacketsLost = 0;
            totalPacketsDiscarded = 0;
        }
    };
 
    static void to_json(nlohmann::json& j, const InboundProcessorStats& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(ssrc),
            TOJSON_IMPL(jitter),
            TOJSON_IMPL(minRtpSamplesInQueue),
            TOJSON_IMPL(maxRtpSamplesInQueue),
            TOJSON_IMPL(totalSamplesTrimmed),
            TOJSON_IMPL(underruns),
            TOJSON_IMPL(overruns),
            TOJSON_IMPL(samplesInQueue),
            TOJSON_IMPL(totalPacketsReceived),
            TOJSON_IMPL(totalPacketsLost),
            TOJSON_IMPL(totalPacketsDiscarded)
        };
    }
    static void from_json(const nlohmann::json& j, InboundProcessorStats& p)
    {
        p.clear();
        getOptional<uint32_t>("ssrc", p.ssrc, j, 0);
        getOptional<double>("jitter", p.jitter, j, 0.0);
        getOptional<uint64_t>("minRtpSamplesInQueue", p.minRtpSamplesInQueue, j, 0);
        getOptional<uint64_t>("maxRtpSamplesInQueue", p.maxRtpSamplesInQueue, j, 0);
        getOptional<uint64_t>("totalSamplesTrimmed", p.totalSamplesTrimmed, j, 0);
        getOptional<uint64_t>("underruns", p.underruns, j, 0);
        getOptional<uint64_t>("overruns", p.overruns, j, 0);
        getOptional<uint64_t>("samplesInQueue", p.samplesInQueue, j, 0);
        getOptional<uint64_t>("totalPacketsReceived", p.totalPacketsReceived, j, 0);
        getOptional<uint64_t>("totalPacketsLost", p.totalPacketsLost, j, 0);
        getOptional<uint64_t>("totalPacketsDiscarded", p.totalPacketsDiscarded, j, 0);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(TrafficCounter)
    class TrafficCounter : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_WRAPPED_JSON_SERIALIZATION(TrafficCounter)
        IMPLEMENT_JSON_DOCUMENTATION(TrafficCounter)
 
    public:
        uint64_t                packets;
        uint64_t                bytes;
        uint64_t                errors;
 
        TrafficCounter()
        {
            clear();
        }
 
        void clear()
        {
            packets = 0;
            bytes = 0;
            errors = 0;
        }
    };
 
    static void to_json(nlohmann::json& j, const TrafficCounter& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(packets),
            TOJSON_IMPL(bytes),
            TOJSON_IMPL(errors)
        };
    }
    static void from_json(const nlohmann::json& j, TrafficCounter& p)
    {
        p.clear();
        getOptional<uint64_t>("packets", p.packets, j, 0);
        getOptional<uint64_t>("bytes", p.bytes, j, 0);
        getOptional<uint64_t>("errors", p.errors, j, 0);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(GroupStats)
    class GroupStats : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_WRAPPED_JSON_SERIALIZATION(GroupStats)
        IMPLEMENT_JSON_DOCUMENTATION(GroupStats)
 
    public:
        std::string                             id;
        //std::vector<InboundProcessorStats>      rtpInbounds;
        TrafficCounter                          rxTraffic;
        TrafficCounter                          txTraffic;
 
        GroupStats()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            //rtpInbounds.clear();
            rxTraffic.clear();
            txTraffic.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const GroupStats& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            //TOJSON_IMPL(rtpInbounds),
            TOJSON_IMPL(rxTraffic),
            TOJSON_IMPL(txTraffic)
        };
    }
    static void from_json(const nlohmann::json& j, GroupStats& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j, EMPTY_STRING);
        //getOptional<std::vector<InboundProcessorStats>>("rtpInbounds", p.rtpInbounds, j);
        getOptional<TrafficCounter>("rxTraffic", p.rxTraffic, j);
        getOptional<TrafficCounter>("txTraffic", p.txTraffic, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(RallypointConnectionDetail)
    class RallypointConnectionDetail : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_WRAPPED_JSON_SERIALIZATION(RallypointConnectionDetail)
        IMPLEMENT_JSON_DOCUMENTATION(RallypointConnectionDetail)
 
    public:
        std::string                                     internalId;
 
        std::string                                     host;
 
        int                                             port;
 
        uint64_t                                        msToNextConnectionAttempt;
 
        float                                           serverProcessingMs;
 
        RallypointConnectionDetail()
        {
            clear();
        }
 
        void clear()
        {
            internalId.clear();
            host.clear();
            port = 0;
            msToNextConnectionAttempt = 0;
            serverProcessingMs = -1.0f;
        }
    };
 
    static void to_json(nlohmann::json& j, const RallypointConnectionDetail& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(internalId),
            TOJSON_IMPL(host),
            TOJSON_IMPL(port)
        };
 
        if(p.msToNextConnectionAttempt > 0)
        {
            j["msToNextConnectionAttempt"] = p.msToNextConnectionAttempt;
        }
 
        if(p.serverProcessingMs >= 0.0)
        {
            j["serverProcessingMs"] = p.serverProcessingMs;
        }
    }
    static void from_json(const nlohmann::json& j, RallypointConnectionDetail& p)
    {
        p.clear();
        getOptional<std::string>("internalId", p.internalId, j, EMPTY_STRING);
        getOptional<std::string>("host", p.host, j, EMPTY_STRING);
        getOptional<int>("port", p.port, j, 0);
        getOptional<uint64_t>("msToNextConnectionAttempt", p.msToNextConnectionAttempt, j, 0);
        getOptional<float>("serverProcessingMs", p.serverProcessingMs, j, -1.0);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(TranslationSession)
    class TranslationSession : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(TranslationSession)
 
    public:
        std::string                 id;
 
        std::string                 name;
 
        std::vector<std::string>    groups;
 
        bool                        enabled;
 
        TranslationSession()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            name.clear();
            groups.clear();
            enabled = true;
        }
    };
 
    static void to_json(nlohmann::json& j, const TranslationSession& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(name),
            TOJSON_IMPL(groups),
            TOJSON_IMPL(enabled)
        };
    }
    static void from_json(const nlohmann::json& j, TranslationSession& p)
    {
        p.clear();
        FROMJSON_IMPL(id, std::string, EMPTY_STRING);
        FROMJSON_IMPL(name, std::string, EMPTY_STRING);
        getOptional<std::vector<std::string>>("groups", p.groups, j);
        FROMJSON_IMPL(enabled, bool, true);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(TranslationConfiguration)
    class TranslationConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(TranslationConfiguration)
 
    public:
        std::vector<TranslationSession>         sessions;
 
        std::vector<Group>                      groups;
 
        TranslationConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            sessions.clear();
            groups.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const TranslationConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(sessions),
            TOJSON_IMPL(groups)
        };
    }
    static void from_json(const nlohmann::json& j, TranslationConfiguration& p)
    {
        p.clear();
        getOptional<std::vector<TranslationSession>>("sessions", p.sessions, j);
        getOptional<std::vector<Group>>("groups", p.groups, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(LingoServerStatusReportConfiguration)
    class LingoServerStatusReportConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(LingoServerStatusReportConfiguration)
 
    public:
        std::string                     fileName;
 
        int                             intervalSecs;
 
        bool                            enabled;
 
        std::string                     runCmd;
 
        bool                            includeGroupDetail;
 
        bool                            includeSessionDetail;
 
        bool                            includeSessionGroupDetail;
 
        LingoServerStatusReportConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            fileName.clear();
            intervalSecs = 60;
            enabled = false;
            includeGroupDetail = false;
            includeSessionDetail = false;
            includeSessionGroupDetail = false;
            runCmd.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const LingoServerStatusReportConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(fileName),
            TOJSON_IMPL(intervalSecs),
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(includeGroupDetail),
            TOJSON_IMPL(includeSessionDetail),
            TOJSON_IMPL(includeSessionGroupDetail),
            TOJSON_IMPL(runCmd)
        };
    }
    static void from_json(const nlohmann::json& j, LingoServerStatusReportConfiguration& p)
    {
        p.clear();
        getOptional<std::string>("fileName", p.fileName, j);
        getOptional<int>("intervalSecs", p.intervalSecs, j, 60);
        getOptional<bool>("enabled", p.enabled, j, false);
        getOptional<std::string>("runCmd", p.runCmd, j);
        getOptional<bool>("includeGroupDetail", p.includeGroupDetail, j, false);
        getOptional<bool>("includeSessionDetail", p.includeSessionDetail, j, false);
        getOptional<bool>("includeSessionGroupDetail", p.includeSessionGroupDetail, j, false);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(LingoServerInternals)
    class LingoServerInternals : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(LingoServerInternals)
 
    public:
        WatchdogSettings    watchdog;
 
        int                 housekeeperIntervalMs;
 
        TuningSettings      tuning; 
 
        LingoServerInternals()
        {
            clear();
        }
 
        void clear()
        {
            watchdog.clear();
            tuning.clear();
            housekeeperIntervalMs = 1000;
        }
    };
 
    static void to_json(nlohmann::json& j, const LingoServerInternals& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(watchdog),
            TOJSON_IMPL(housekeeperIntervalMs),
            TOJSON_IMPL(tuning)
        };
    }
    static void from_json(const nlohmann::json& j, LingoServerInternals& p)
    {
        p.clear();
        getOptional<WatchdogSettings>("watchdog", p.watchdog, j);
        getOptional<int>("housekeeperIntervalMs", p.housekeeperIntervalMs, j, 1000);
        getOptional<TuningSettings>("tuning", p.tuning, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(LingoServerConfiguration)
    class LingoServerConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(LingoServerConfiguration)
 
    public:
        std::string                                 id;
 
        int                                         serviceConfigurationFileCheckSecs;
        
        std::string                                 lingoConfigurationFileName;
 
        std::string                                 lingoConfigurationFileCommand;
 
        int                                         lingoConfigurationFileCheckSecs;
 
        LingoServerStatusReportConfiguration        statusReport;
 
        ExternalHealthCheckResponder                externalHealthCheckResponder;
 
        LingoServerInternals                        internals;
 
        std::string                                 certStoreFileName;
 
        std::string                                 certStorePasswordHex;
 
        EnginePolicy                                enginePolicy;
 
        std::string                                 configurationCheckSignalName;
 
        FipsCryptoSettings                          fipsCrypto;
 
        NetworkAddress                              proxy;
 
        NsmConfiguration                            nsm;
 
        LingoServerConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            serviceConfigurationFileCheckSecs = 60;
            lingoConfigurationFileName.clear();
            lingoConfigurationFileCommand.clear();
            lingoConfigurationFileCheckSecs = 60;
            statusReport.clear();
            externalHealthCheckResponder.clear();
            internals.clear();
            certStoreFileName.clear();
            certStorePasswordHex.clear();
            enginePolicy.clear();
            configurationCheckSignalName = "rts.22f4ec3.${id}";
            fipsCrypto.clear();
            proxy.clear();
            nsm.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const LingoServerConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(serviceConfigurationFileCheckSecs),
            TOJSON_IMPL(lingoConfigurationFileName),
            TOJSON_IMPL(lingoConfigurationFileCommand),
            TOJSON_IMPL(lingoConfigurationFileCheckSecs),
            TOJSON_IMPL(statusReport),
            TOJSON_IMPL(externalHealthCheckResponder),
            TOJSON_IMPL(internals),
            TOJSON_IMPL(certStoreFileName),
            TOJSON_IMPL(certStorePasswordHex),
            TOJSON_IMPL(enginePolicy),
            TOJSON_IMPL(configurationCheckSignalName),
            TOJSON_IMPL(fipsCrypto),
            TOJSON_IMPL(proxy),
            TOJSON_IMPL(nsm)
        };
    }
    static void from_json(const nlohmann::json& j, LingoServerConfiguration& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j);
        getOptional<int>("serviceConfigurationFileCheckSecs", p.serviceConfigurationFileCheckSecs, j, 60);
        getOptional<std::string>("lingoConfigurationFileName", p.lingoConfigurationFileName, j);
        getOptional<std::string>("lingoConfigurationFileCommand", p.lingoConfigurationFileCommand, j);
        getOptional<int>("lingoConfigurationFileCheckSecs", p.lingoConfigurationFileCheckSecs, j, 60);
        getOptional<LingoServerStatusReportConfiguration>("statusReport", p.statusReport, j);
        getOptional<ExternalHealthCheckResponder>("externalHealthCheckResponder", p.externalHealthCheckResponder, j);
        getOptional<LingoServerInternals>("internals", p.internals, j);
        getOptional<std::string>("certStoreFileName", p.certStoreFileName, j);
        getOptional<std::string>("certStorePasswordHex", p.certStorePasswordHex, j);
        j.at("enginePolicy").get_to(p.enginePolicy);
        getOptional<std::string>("configurationCheckSignalName", p.configurationCheckSignalName, j, "rts.22f4ec3.${id}");
        getOptional<FipsCryptoSettings>("fipsCrypo", p.fipsCrypto, j);
        getOptional<NetworkAddress>("proxy", p.proxy, j);
        getOptional<NsmConfiguration>("nsm", p.nsm, j);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(VoiceToVoiceSession)
    class VoiceToVoiceSession : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(VoiceToVoiceSession)
 
    public:
        std::string                 id;
 
        std::string                 name;
 
        std::vector<std::string>    groups;
 
        bool                        enabled;
 
        VoiceToVoiceSession()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            name.clear();
            groups.clear();
            enabled = true;
        }
    };
 
    static void to_json(nlohmann::json& j, const VoiceToVoiceSession& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(name),
            TOJSON_IMPL(groups),
            TOJSON_IMPL(enabled)
        };
    }
    static void from_json(const nlohmann::json& j, VoiceToVoiceSession& p)
    {
        p.clear();
        FROMJSON_IMPL(id, std::string, EMPTY_STRING);
        FROMJSON_IMPL(name, std::string, EMPTY_STRING);
        getOptional<std::vector<std::string>>("groups", p.groups, j);
        FROMJSON_IMPL(enabled, bool, true);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(LingoConfiguration)
    class LingoConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(LingoConfiguration)
 
    public:
        std::vector<VoiceToVoiceSession>         voiceToVoiceSessions;
 
        std::vector<Group>                       groups;
 
        LingoConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            voiceToVoiceSessions.clear();
            groups.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const LingoConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(voiceToVoiceSessions),
            TOJSON_IMPL(groups)
        };
    }
    static void from_json(const nlohmann::json& j, LingoConfiguration& p)
    {
        p.clear();
        getOptional<std::vector<VoiceToVoiceSession>>("voiceToVoiceSessions", p.voiceToVoiceSessions, j);
        getOptional<std::vector<Group>>("groups", p.groups, j);
    }
    
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(BridgingConfiguration)
    class BridgingConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(BridgingConfiguration)
 
    public:
        std::vector<Bridge>         bridges;
 
        std::vector<Group>          groups;
 
        BridgingConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            bridges.clear();
            groups.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const BridgingConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(bridges),
            TOJSON_IMPL(groups)
        };
    }
    static void from_json(const nlohmann::json& j, BridgingConfiguration& p)
    {
        p.clear();
        getOptional<std::vector<Bridge>>("bridges", p.bridges, j);
        getOptional<std::vector<Group>>("groups", p.groups, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(BridgingServerStatusReportConfiguration)
    class BridgingServerStatusReportConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(BridgingServerStatusReportConfiguration)
 
    public:
        std::string                     fileName;
 
        int                             intervalSecs;
 
        bool                            enabled;
 
        std::string                     runCmd;
 
        bool                            includeGroupDetail;
 
        bool                            includeBridgeDetail;
 
        bool                            includeBridgeGroupDetail;
 
        BridgingServerStatusReportConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            fileName.clear();
            intervalSecs = 60;
            enabled = false;
            includeGroupDetail = false;
            includeBridgeDetail = false;
            includeBridgeGroupDetail = false;
            runCmd.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const BridgingServerStatusReportConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(fileName),
            TOJSON_IMPL(intervalSecs),
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(includeGroupDetail),
            TOJSON_IMPL(includeBridgeDetail),
            TOJSON_IMPL(includeBridgeGroupDetail),
            TOJSON_IMPL(runCmd)
        };
    }
    static void from_json(const nlohmann::json& j, BridgingServerStatusReportConfiguration& p)
    {
        p.clear();
        getOptional<std::string>("fileName", p.fileName, j);
        getOptional<int>("intervalSecs", p.intervalSecs, j, 60);
        getOptional<bool>("enabled", p.enabled, j, false);
        getOptional<std::string>("runCmd", p.runCmd, j);
        getOptional<bool>("includeGroupDetail", p.includeGroupDetail, j, false);
        getOptional<bool>("includeBridgeDetail", p.includeBridgeDetail, j, false);
        getOptional<bool>("includeBridgeGroupDetail", p.includeBridgeGroupDetail, j, false);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(BridgingServerInternals)
    class BridgingServerInternals : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(BridgingServerInternals)
 
    public:
        WatchdogSettings    watchdog;
 
        int                 housekeeperIntervalMs;
 
        TuningSettings      tuning; 
 
        BridgingServerInternals()
        {
            clear();
        }
 
        void clear()
        {
            watchdog.clear();
            tuning.clear();
            housekeeperIntervalMs = 1000;
        }
    };
 
    static void to_json(nlohmann::json& j, const BridgingServerInternals& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(watchdog),
            TOJSON_IMPL(housekeeperIntervalMs),
            TOJSON_IMPL(tuning)            
        };
    }
    static void from_json(const nlohmann::json& j, BridgingServerInternals& p)
    {
        p.clear();
        getOptional<WatchdogSettings>("watchdog", p.watchdog, j);
        getOptional<int>("housekeeperIntervalMs", p.housekeeperIntervalMs, j, 1000);
        getOptional<TuningSettings>("tuning", p.tuning, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(BridgingServerConfiguration)
    class BridgingServerConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(BridgingServerConfiguration)
 
    public:
        typedef enum
        {
            omRaw                       = 0,
 
            omMultistream               = 1,
 
            omMixedStream               = 2,
 
            omADictatedByGroup          = 3,
        } OpMode_t;
 
        std::string                                 id;
 
        OpMode_t                                    mode;
 
        int                                         serviceConfigurationFileCheckSecs;
        
        std::string                                 bridgingConfigurationFileName;
 
        std::string                                 bridgingConfigurationFileCommand;
 
        int                                         bridgingConfigurationFileCheckSecs;
 
        BridgingServerStatusReportConfiguration     statusReport;
 
        ExternalHealthCheckResponder                 externalHealthCheckResponder;
 
        BridgingServerInternals                     internals;
 
        std::string                                 certStoreFileName;
 
        std::string                                 certStorePasswordHex;
 
        EnginePolicy                                enginePolicy;
 
        std::string                                 configurationCheckSignalName;
 
        FipsCryptoSettings                          fipsCrypto;
 
        NsmConfiguration                            nsm;
 
        BridgingServerConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            mode = omRaw;
            serviceConfigurationFileCheckSecs = 60;
            bridgingConfigurationFileName.clear();
            bridgingConfigurationFileCommand.clear();
            bridgingConfigurationFileCheckSecs = 60;
            statusReport.clear();
            externalHealthCheckResponder.clear();
            internals.clear();
            certStoreFileName.clear();
            certStorePasswordHex.clear();
            enginePolicy.clear();
            configurationCheckSignalName = "rts.6cc0651.${id}";
            fipsCrypto.clear();
            nsm.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const BridgingServerConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(mode),
            TOJSON_IMPL(serviceConfigurationFileCheckSecs),
            TOJSON_IMPL(bridgingConfigurationFileName),
            TOJSON_IMPL(bridgingConfigurationFileCommand),
            TOJSON_IMPL(bridgingConfigurationFileCheckSecs),
            TOJSON_IMPL(statusReport),
            TOJSON_IMPL(externalHealthCheckResponder),
            TOJSON_IMPL(internals),
            TOJSON_IMPL(certStoreFileName),
            TOJSON_IMPL(certStorePasswordHex),
            TOJSON_IMPL(enginePolicy),
            TOJSON_IMPL(configurationCheckSignalName),
            TOJSON_IMPL(fipsCrypto),
            TOJSON_IMPL(nsm)
        };
    }
    static void from_json(const nlohmann::json& j, BridgingServerConfiguration& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j);
        getOptional<BridgingServerConfiguration::OpMode_t>("mode", p.mode, j, BridgingServerConfiguration::OpMode_t::omRaw);
        getOptional<int>("serviceConfigurationFileCheckSecs", p.serviceConfigurationFileCheckSecs, j, 60);
        getOptional<std::string>("bridgingConfigurationFileName", p.bridgingConfigurationFileName, j);
        getOptional<std::string>("bridgingConfigurationFileCommand", p.bridgingConfigurationFileCommand, j);
        getOptional<int>("bridgingConfigurationFileCheckSecs", p.bridgingConfigurationFileCheckSecs, j, 60);
        getOptional<BridgingServerStatusReportConfiguration>("statusReport", p.statusReport, j);
        getOptional<ExternalHealthCheckResponder>("externalHealthCheckResponder", p.externalHealthCheckResponder, j);
        getOptional<BridgingServerInternals>("internals", p.internals, j);
        getOptional<std::string>("certStoreFileName", p.certStoreFileName, j);
        getOptional<std::string>("certStorePasswordHex", p.certStorePasswordHex, j);
        j.at("enginePolicy").get_to(p.enginePolicy);
        getOptional<std::string>("configurationCheckSignalName", p.configurationCheckSignalName, j, "rts.6cc0651.${id}");
        getOptional<FipsCryptoSettings>("fipsCrypto", p.fipsCrypto, j);
        getOptional<NsmConfiguration>("nsm", p.nsm, j);
    }
 
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EarGroupsConfiguration)
    class EarGroupsConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EarGroupsConfiguration)
 
    public:
        std::vector<Group>          groups;
 
        EarGroupsConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            groups.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const EarGroupsConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(groups)
        };
    }
    static void from_json(const nlohmann::json& j, EarGroupsConfiguration& p)
    {
        p.clear();
        getOptional<std::vector<Group>>("groups", p.groups, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EarServerStatusReportConfiguration)
    class EarServerStatusReportConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EarServerStatusReportConfiguration)
 
    public:
        std::string                     fileName;
 
        int                             intervalSecs;
 
        bool                            enabled;
 
        std::string                     runCmd;
 
        bool                            includeGroupDetail;
 
        EarServerStatusReportConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            fileName.clear();
            intervalSecs = 60;
            enabled = false;
            includeGroupDetail = false;
            runCmd.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const EarServerStatusReportConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(fileName),
            TOJSON_IMPL(intervalSecs),
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(includeGroupDetail),
            TOJSON_IMPL(runCmd)
        };
    }
    static void from_json(const nlohmann::json& j, EarServerStatusReportConfiguration& p)
    {
        p.clear();
        getOptional<std::string>("fileName", p.fileName, j);
        getOptional<int>("intervalSecs", p.intervalSecs, j, 60);
        getOptional<bool>("enabled", p.enabled, j, false);
        getOptional<std::string>("runCmd", p.runCmd, j);
        getOptional<bool>("includeGroupDetail", p.includeGroupDetail, j, false);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EarServerInternals)
    class EarServerInternals : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EarServerInternals)
 
    public:
        WatchdogSettings    watchdog;
 
        int                 housekeeperIntervalMs;
 
        TuningSettings      tuning; 
 
        EarServerInternals()
        {
            clear();
        }
 
        void clear()
        {
            watchdog.clear();
            tuning.clear();
            housekeeperIntervalMs = 1000;
        }
    };
 
    static void to_json(nlohmann::json& j, const EarServerInternals& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(watchdog),
            TOJSON_IMPL(housekeeperIntervalMs),
            TOJSON_IMPL(tuning)
        };
    }
    static void from_json(const nlohmann::json& j, EarServerInternals& p)
    {
        p.clear();
        getOptional<WatchdogSettings>("watchdog", p.watchdog, j);
        getOptional<int>("housekeeperIntervalMs", p.housekeeperIntervalMs, j, 1000);
        getOptional<TuningSettings>("tuning", p.tuning, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EarServerConfiguration)
    class EarServerConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EarServerConfiguration)
 
    public:
 
        std::string                                 id;
 
        int                                         serviceConfigurationFileCheckSecs;
        
        std::string                                 groupsConfigurationFileName;
 
        std::string                                 groupsConfigurationFileCommand;
 
        int                                         groupsConfigurationFileCheckSecs;
 
        EarServerStatusReportConfiguration          statusReport;
 
        ExternalHealthCheckResponder                 externalHealthCheckResponder;
 
        EarServerInternals                           internals;
 
        std::string                                  certStoreFileName;
 
        std::string                                  certStorePasswordHex;
 
        EnginePolicy                                 enginePolicy;
 
        std::string                                 configurationCheckSignalName;
 
        FipsCryptoSettings                          fipsCrypto;
 
        NsmConfiguration                            nsm;
 
        EarServerConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            serviceConfigurationFileCheckSecs = 60;
            groupsConfigurationFileName.clear();
            groupsConfigurationFileCommand.clear();
            groupsConfigurationFileCheckSecs = 60;
            statusReport.clear();
            externalHealthCheckResponder.clear();
            internals.clear();
            certStoreFileName.clear();
            certStorePasswordHex.clear();
            enginePolicy.clear();
            configurationCheckSignalName = "rts.9a164fa.${id}";
            fipsCrypto.clear();
            nsm.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const EarServerConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(serviceConfigurationFileCheckSecs),
            TOJSON_IMPL(groupsConfigurationFileName),
            TOJSON_IMPL(groupsConfigurationFileCommand),
            TOJSON_IMPL(groupsConfigurationFileCheckSecs),
            TOJSON_IMPL(statusReport),
            TOJSON_IMPL(externalHealthCheckResponder),
            TOJSON_IMPL(internals),
            TOJSON_IMPL(certStoreFileName),
            TOJSON_IMPL(certStorePasswordHex),
            TOJSON_IMPL(enginePolicy),
            TOJSON_IMPL(configurationCheckSignalName),
            TOJSON_IMPL(fipsCrypto),
            TOJSON_IMPL(nsm)
        };
    }
    static void from_json(const nlohmann::json& j, EarServerConfiguration& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j);
        getOptional<int>("serviceConfigurationFileCheckSecs", p.serviceConfigurationFileCheckSecs, j, 60);
        getOptional<std::string>("groupsConfigurationFileName", p.groupsConfigurationFileName, j);
        getOptional<std::string>("groupsConfigurationFileCommand", p.groupsConfigurationFileCommand, j);
        getOptional<int>("groupsConfigurationFileCheckSecs", p.groupsConfigurationFileCheckSecs, j, 60);
        getOptional<EarServerStatusReportConfiguration>("statusReport", p.statusReport, j);
        getOptional<ExternalHealthCheckResponder>("externalHealthCheckResponder", p.externalHealthCheckResponder, j);
        getOptional<EarServerInternals>("internals", p.internals, j);
        getOptional<std::string>("certStoreFileName", p.certStoreFileName, j);
        getOptional<std::string>("certStorePasswordHex", p.certStorePasswordHex, j);
        j.at("enginePolicy").get_to(p.enginePolicy);
        getOptional<std::string>("configurationCheckSignalName", p.configurationCheckSignalName, j, "rts.9a164fa.${id}");
        getOptional<FipsCryptoSettings>("fipsCrypto", p.fipsCrypto, j);
        getOptional<NsmConfiguration>("nsm", p.nsm, j);
    }
 
//-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EngageSemGroupsConfiguration)
    class EngageSemGroupsConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EngageSemGroupsConfiguration)
 
    public:
        std::vector<Group>          groups;
 
        EngageSemGroupsConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            groups.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const EngageSemGroupsConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(groups)
        };
    }
    static void from_json(const nlohmann::json& j, EngageSemGroupsConfiguration& p)
    {
        p.clear();
        getOptional<std::vector<Group>>("groups", p.groups, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EngageSemServerStatusReportConfiguration)
    class EngageSemServerStatusReportConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EngageSemServerStatusReportConfiguration)
 
    public:
        std::string                     fileName;
 
        int                             intervalSecs;
 
        bool                            enabled;
 
        std::string                     runCmd;
 
        bool                            includeGroupDetail;
 
        EngageSemServerStatusReportConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            fileName.clear();
            intervalSecs = 60;
            enabled = false;
            includeGroupDetail = false;
            runCmd.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const EngageSemServerStatusReportConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(fileName),
            TOJSON_IMPL(intervalSecs),
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(includeGroupDetail),
            TOJSON_IMPL(runCmd)
        };
    }
    static void from_json(const nlohmann::json& j, EngageSemServerStatusReportConfiguration& p)
    {
        p.clear();
        getOptional<std::string>("fileName", p.fileName, j);
        getOptional<int>("intervalSecs", p.intervalSecs, j, 60);
        getOptional<bool>("enabled", p.enabled, j, false);
        getOptional<std::string>("runCmd", p.runCmd, j);
        getOptional<bool>("includeGroupDetail", p.includeGroupDetail, j, false);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EngageSemServerInternals)
    class EngageSemServerInternals : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EngageSemServerInternals)
 
    public:
        WatchdogSettings    watchdog;
 
        int                 housekeeperIntervalMs;
 
        TuningSettings      tuning; 
 
        EngageSemServerInternals()
        {
            clear();
        }
 
        void clear()
        {
            watchdog.clear();
            tuning.clear();
            housekeeperIntervalMs = 1000;
        }
    };
 
    static void to_json(nlohmann::json& j, const EngageSemServerInternals& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(watchdog),
            TOJSON_IMPL(housekeeperIntervalMs),
            TOJSON_IMPL(tuning)
        };
    }
    static void from_json(const nlohmann::json& j, EngageSemServerInternals& p)
    {
        p.clear();
        getOptional<WatchdogSettings>("watchdog", p.watchdog, j);
        getOptional<int>("housekeeperIntervalMs", p.housekeeperIntervalMs, j, 1000);
        getOptional<TuningSettings>("tuning", p.tuning, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EngageSemServerConfiguration)
    class EngageSemServerConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EngageSemServerConfiguration)
 
    public:
 
        std::string                                 id;
 
        int                                         serviceConfigurationFileCheckSecs;
        
        std::string                                 groupsConfigurationFileName;
 
        std::string                                 groupsConfigurationFileCommand;
 
        int                                         groupsConfigurationFileCheckSecs;
 
        EngageSemServerStatusReportConfiguration          statusReport;
 
        ExternalHealthCheckResponder                 externalHealthCheckResponder;
 
        EngageSemServerInternals                           internals;
 
        std::string                                  certStoreFileName;
 
        std::string                                  certStorePasswordHex;
 
        EnginePolicy                                 enginePolicy;
 
        std::string                                 configurationCheckSignalName;
 
        FipsCryptoSettings                          fipsCrypto;
 
        NsmConfiguration                            nsm;
 
        int                                         maxQueueLen;
        int                                         minQueuingMs;
        int                                         maxQueuingMs;
        int                                         minPriority;
        int                                         maxPriority;
 
        EngageSemServerConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            serviceConfigurationFileCheckSecs = 60;
            groupsConfigurationFileName.clear();
            groupsConfigurationFileCommand.clear();
            groupsConfigurationFileCheckSecs = 60;
            statusReport.clear();
            externalHealthCheckResponder.clear();
            internals.clear();
            certStoreFileName.clear();
            certStorePasswordHex.clear();
            enginePolicy.clear();
            configurationCheckSignalName = "rts.9a164fa.${id}";
            fipsCrypto.clear();
            nsm.clear();
 
            maxQueueLen = 64;
            minQueuingMs = 0;
            maxQueuingMs = 15000;
            minPriority = 0;
            maxPriority = 255;
        }
    };
 
    static void to_json(nlohmann::json& j, const EngageSemServerConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(serviceConfigurationFileCheckSecs),
            TOJSON_IMPL(groupsConfigurationFileName),
            TOJSON_IMPL(groupsConfigurationFileCommand),
            TOJSON_IMPL(groupsConfigurationFileCheckSecs),
            TOJSON_IMPL(statusReport),
            TOJSON_IMPL(externalHealthCheckResponder),
            TOJSON_IMPL(internals),
            TOJSON_IMPL(certStoreFileName),
            TOJSON_IMPL(certStorePasswordHex),
            TOJSON_IMPL(enginePolicy),
            TOJSON_IMPL(configurationCheckSignalName),
            TOJSON_IMPL(fipsCrypto),
            TOJSON_IMPL(nsm),
            TOJSON_IMPL(maxQueueLen),
            TOJSON_IMPL(minQueuingMs),
            TOJSON_IMPL(maxQueuingMs),
            TOJSON_IMPL(minPriority),
            TOJSON_IMPL(maxPriority)
        };
    }
    static void from_json(const nlohmann::json& j, EngageSemServerConfiguration& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j);
        getOptional<int>("serviceConfigurationFileCheckSecs", p.serviceConfigurationFileCheckSecs, j, 60);
        getOptional<std::string>("groupsConfigurationFileName", p.groupsConfigurationFileName, j);
        getOptional<std::string>("groupsConfigurationFileCommand", p.groupsConfigurationFileCommand, j);
        getOptional<int>("groupsConfigurationFileCheckSecs", p.groupsConfigurationFileCheckSecs, j, 60);
        getOptional<EngageSemServerStatusReportConfiguration>("statusReport", p.statusReport, j);
        getOptional<ExternalHealthCheckResponder>("externalHealthCheckResponder", p.externalHealthCheckResponder, j);
        getOptional<EngageSemServerInternals>("internals", p.internals, j);
        getOptional<std::string>("certStoreFileName", p.certStoreFileName, j);
        getOptional<std::string>("certStorePasswordHex", p.certStorePasswordHex, j);
        j.at("enginePolicy").get_to(p.enginePolicy);
        getOptional<std::string>("configurationCheckSignalName", p.configurationCheckSignalName, j, "rts.9a164fa.${id}");
        getOptional<FipsCryptoSettings>("fipsCrypto", p.fipsCrypto, j);
        getOptional<NsmConfiguration>("nsm", p.nsm, j);
        getOptional<int>("maxQueueLen", p.maxQueueLen, j, 64);
        getOptional<int>("minQueuingMs", p.minQueuingMs, j, 0);
        getOptional<int>("maxQueuingMs", p.maxQueuingMs, j, 15000);
        getOptional<int>("minPriority", p.minPriority, j, 0);
        getOptional<int>("maxPriority", p.maxPriority, j, 255);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EngateGroup)
    class EngateGroup : public Group
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EngateGroup)
 
    public:
        bool                        useVad;
        uint32_t                    inputHangMs;
        uint32_t                    inputActivationPowerThreshold;
        uint32_t                    inputDeactivationPowerThreshold;
 
        EngateGroup()
        {
            clear();
        }
 
        void clear()
        {
            Group::clear();
            useVad = false;
            inputHangMs = 750;
            inputActivationPowerThreshold = 700;
            inputDeactivationPowerThreshold = 125;
        }
    };
 
    static void to_json(nlohmann::json& j, const EngateGroup& p)
    {
        nlohmann::json g;
        to_json(g, static_cast<const Group&>(p));
 
        j = nlohmann::json{
            TOJSON_IMPL(useVad),
            TOJSON_IMPL(inputHangMs),
            TOJSON_IMPL(inputActivationPowerThreshold),
            TOJSON_IMPL(inputDeactivationPowerThreshold)
        };
    }
    static void from_json(const nlohmann::json& j, EngateGroup& p)
    {
        p.clear();
        from_json(j, static_cast<Group&>(p));
        getOptional<uint32_t>("inputHangMs", p.inputHangMs, j, 750);
        getOptional<uint32_t>("inputActivationPowerThreshold", p.inputActivationPowerThreshold, j, 700);
        getOptional<uint32_t>("inputDeactivationPowerThreshold", p.inputDeactivationPowerThreshold, j, 125);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EngateGroupsConfiguration)
    class EngateGroupsConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EngateGroupsConfiguration)
 
    public:
        std::vector<EngateGroup>          groups;
 
        EngateGroupsConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            groups.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const EngateGroupsConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(groups)
        };
    }
    static void from_json(const nlohmann::json& j, EngateGroupsConfiguration& p)
    {
        p.clear();
        getOptional<std::vector<EngateGroup>>("groups", p.groups, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EngateServerStatusReportConfiguration)
    class EngateServerStatusReportConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EngateServerStatusReportConfiguration)
 
    public:
        std::string                     fileName;
 
        int                             intervalSecs;
 
        bool                            enabled;
 
        std::string                     runCmd;
 
        bool                            includeGroupDetail;
 
        EngateServerStatusReportConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            fileName.clear();
            intervalSecs = 60;
            enabled = false;
            includeGroupDetail = false;
            runCmd.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const EngateServerStatusReportConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(fileName),
            TOJSON_IMPL(intervalSecs),
            TOJSON_IMPL(enabled),
            TOJSON_IMPL(includeGroupDetail),
            TOJSON_IMPL(runCmd)
        };
    }
    static void from_json(const nlohmann::json& j, EngateServerStatusReportConfiguration& p)
    {
        p.clear();
        getOptional<std::string>("fileName", p.fileName, j);
        getOptional<int>("intervalSecs", p.intervalSecs, j, 60);
        getOptional<bool>("enabled", p.enabled, j, false);
        getOptional<std::string>("runCmd", p.runCmd, j);
        getOptional<bool>("includeGroupDetail", p.includeGroupDetail, j, false);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EngateServerInternals)
    class EngateServerInternals : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EngateServerInternals)
 
    public:
        WatchdogSettings    watchdog;
 
        int                 housekeeperIntervalMs;
 
        TuningSettings      tuning; 
 
        EngateServerInternals()
        {
            clear();
        }
 
        void clear()
        {
            watchdog.clear();
            tuning.clear();
            housekeeperIntervalMs = 1000;
        }
    };
 
    static void to_json(nlohmann::json& j, const EngateServerInternals& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(watchdog),
            TOJSON_IMPL(housekeeperIntervalMs),
            TOJSON_IMPL(tuning)
        };
    }
    static void from_json(const nlohmann::json& j, EngateServerInternals& p)
    {
        p.clear();
        getOptional<WatchdogSettings>("watchdog", p.watchdog, j);
        getOptional<int>("housekeeperIntervalMs", p.housekeeperIntervalMs, j, 1000);
        getOptional<TuningSettings>("tuning", p.tuning, j);
    }
 
    //-----------------------------------------------------------
    JSON_SERIALIZED_CLASS(EngateServerConfiguration)
    class EngateServerConfiguration : public ConfigurationObjectBase
    {
        IMPLEMENT_JSON_SERIALIZATION()
        IMPLEMENT_JSON_DOCUMENTATION(EngateServerConfiguration)
 
    public:
 
        std::string                                 id;
 
        int                                         serviceConfigurationFileCheckSecs;
        
        std::string                                 groupsConfigurationFileName;
 
        std::string                                 groupsConfigurationFileCommand;
 
        int                                         groupsConfigurationFileCheckSecs;
 
        EngateServerStatusReportConfiguration          statusReport;
 
        ExternalHealthCheckResponder                 externalHealthCheckResponder;
 
        EngateServerInternals                           internals;
 
        std::string                                  certStoreFileName;
 
        std::string                                  certStorePasswordHex;
 
        EnginePolicy                                 enginePolicy;
 
        std::string                                 configurationCheckSignalName;
 
        FipsCryptoSettings                          fipsCrypto;
 
        NsmConfiguration                            nsm;
 
        EngateServerConfiguration()
        {
            clear();
        }
 
        void clear()
        {
            id.clear();
            serviceConfigurationFileCheckSecs = 60;
            groupsConfigurationFileName.clear();
            groupsConfigurationFileCommand.clear();
            groupsConfigurationFileCheckSecs = 60;
            statusReport.clear();
            externalHealthCheckResponder.clear();
            internals.clear();
            certStoreFileName.clear();
            certStorePasswordHex.clear();
            enginePolicy.clear();
            configurationCheckSignalName = "rts.9a164fa.${id}";
            fipsCrypto.clear();
            nsm.clear();
        }
    };
 
    static void to_json(nlohmann::json& j, const EngateServerConfiguration& p)
    {
        j = nlohmann::json{
            TOJSON_IMPL(id),
            TOJSON_IMPL(serviceConfigurationFileCheckSecs),
            TOJSON_IMPL(groupsConfigurationFileName),
            TOJSON_IMPL(groupsConfigurationFileCommand),
            TOJSON_IMPL(groupsConfigurationFileCheckSecs),
            TOJSON_IMPL(statusReport),
            TOJSON_IMPL(externalHealthCheckResponder),
            TOJSON_IMPL(internals),
            TOJSON_IMPL(certStoreFileName),
            TOJSON_IMPL(certStorePasswordHex),
            TOJSON_IMPL(enginePolicy),
            TOJSON_IMPL(configurationCheckSignalName),
            TOJSON_IMPL(fipsCrypto),
            TOJSON_IMPL(nsm)
        };
    }
    static void from_json(const nlohmann::json& j, EngateServerConfiguration& p)
    {
        p.clear();
        getOptional<std::string>("id", p.id, j);
        getOptional<int>("serviceConfigurationFileCheckSecs", p.serviceConfigurationFileCheckSecs, j, 60);
        getOptional<std::string>("groupsConfigurationFileName", p.groupsConfigurationFileName, j);
        getOptional<std::string>("groupsConfigurationFileCommand", p.groupsConfigurationFileCommand, j);
        getOptional<int>("groupsConfigurationFileCheckSecs", p.groupsConfigurationFileCheckSecs, j, 60);
        getOptional<EngateServerStatusReportConfiguration>("statusReport", p.statusReport, j);
        getOptional<ExternalHealthCheckResponder>("externalHealthCheckResponder", p.externalHealthCheckResponder, j);
        getOptional<EngateServerInternals>("internals", p.internals, j);
        getOptional<std::string>("certStoreFileName", p.certStoreFileName, j);
        getOptional<std::string>("certStorePasswordHex", p.certStorePasswordHex, j);
        j.at("enginePolicy").get_to(p.enginePolicy);
        getOptional<std::string>("configurationCheckSignalName", p.configurationCheckSignalName, j, "rts.9a164fa.${id}");
        getOptional<FipsCryptoSettings>("fipsCrypto", p.fipsCrypto, j);
        getOptional<NsmConfiguration>("nsm", p.nsm, j);
    }    
 
    //-----------------------------------------------------------
    static inline void dumpExampleConfigurations(const char *path)
    {
        WatchdogSettings::document();
        FileRecordingRequest::document();
        Feature::document();
        Featureset::document();
        Agc::document();
        RtpPayloadTypeTranslation::document();
        NetworkInterfaceDevice::document();
        ListOfNetworkInterfaceDevice::document();
        RtpHeader::document();
        BlobInfo::document();
        TxAudioUri::document();
        AdvancedTxParams::document();
        Identity::document();
        Location::document();
        Power::document();
        Connectivity::document();
        PresenceDescriptorGroupItem::document();
        PresenceDescriptor::document();
        NetworkTxOptions::document();
        TcpNetworkTxOptions::document();
        NetworkAddress::document();
        NetworkAddressRxTx::document();
        NetworkAddressRestrictionList::document();
        StringRestrictionList::document();
        Rallypoint::document();
        RallypointCluster::document();
        NetworkDeviceDescriptor::document();
        TxAudio::document();
        AudioDeviceDescriptor::document();
        ListOfAudioDeviceDescriptor::document();
        Audio::document();
        TalkerInformation::document();
        GroupTalkers::document();
        Presence::document();
        Advertising::document();
        GroupPriorityTranslation::document();
        GroupTimeline::document();
        GroupAppTransport::document();
        RtpProfile::document();
        Group::document();
        Mission::document();
        LicenseDescriptor::document();
        EngineNetworkingRpUdpStreaming::document();
        EnginePolicyNetworking::document();
        Aec::document();
        Vad::document();
        Bridge::document();
        AndroidAudio::document();
        EnginePolicyAudio::document();
        SecurityCertificate::document();
        EnginePolicySecurity::document();
        EnginePolicyLogging::document();
        EnginePolicyDatabase::document();
        NamedAudioDevice::document();
        EnginePolicyNamedAudioDevices::document();
        Licensing::document();
        DiscoveryMagellan::document();
        DiscoverySsdp::document();
        DiscoverySap::document();
        DiscoveryCistech::document();
        DiscoveryTrellisware::document();
        DiscoveryConfiguration::document();
        EnginePolicyInternals::document();
        EnginePolicyTimelines::document();
        RtpMapEntry::document();
        ExternalModule::document();
        ExternalCodecDescriptor::document();
        EnginePolicy::document();
        TalkgroupAsset::document();
        EngageDiscoveredGroup::document();
        RallypointPeer::document();
        RallypointServerLimits::document();
        RallypointServerStatusReportConfiguration::document();
        RallypointServerLinkGraph::document();
        ExternalHealthCheckResponder::document();
        Tls::document();
        PeeringConfiguration::document();
        IgmpSnooping::document();
        RallypointReflector::document();
        RallypointUdpStreaming::document();
        RallypointServer::document();
        PlatformDiscoveredService::document();
        TimelineQueryParameters::document();
        CertStoreCertificate::document();
        CertStore::document();
        CertStoreCertificateElement::document();
        CertStoreDescriptor::document();
        CertificateDescriptor::document();
        BridgeCreationDetail::document();
        GroupConnectionDetail::document();
        GroupTxDetail::document();
        GroupCreationDetail::document();
        GroupReconfigurationDetail::document();
        GroupHealthReport::document();
        InboundProcessorStats::document();
        TrafficCounter::document();
        GroupStats::document();
        RallypointConnectionDetail::document();
        BridgingConfiguration::document();
        BridgingServerStatusReportConfiguration::document();
        BridgingServerInternals::document();
        BridgingServerConfiguration::document();
        EarGroupsConfiguration::document();
        EarServerStatusReportConfiguration::document();
        EarServerInternals::document();
        EarServerConfiguration::document();
        RangerPackets::document();
        TransportImpairment::document();
 
        EngageSemGroupsConfiguration::document();
        EngageSemServerStatusReportConfiguration::document();
        EngageSemServerInternals::document();
        EngageSemServerConfiguration::document();
    }
}
 
#ifndef WIN32
    #pragma GCC diagnostic pop
#endif
 
#endif /* ConfigurationObjects_h */