engage-engine 1.232.90720005 → 1.234.90740001

package/include/ConfigurationObjects.h

@@ -248,31 +248,45 @@ namespace AppConfigurationObjects
         \
         std::string serialize(const int indent = -1) \
         { \
-            nlohmann::json j; \
-            to_json(j, *this); \
-            return j.dump(indent); \
+            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) \
         { \
-            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; \
+            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) \
@@ -2174,6 +2188,196 @@ namespace AppConfigurationObjects
     }
 
 
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(TransportImpairment)
+    /**
+     * @brief Description of a transport impairment
+     *
+     * Helper C++ class to serialize and de-serialize TransportImpairment JSON.
+     *
+     * Example: @include[doc] examples/TransportImpairment.json
+     *
+     */
+    class TransportImpairment : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(TransportImpairment)
+
+    public:
+        int     applicationPercentage;
+        int     jitterMs;
+        int     lossPercentage;
+
+        TransportImpairment()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            applicationPercentage = 0;
+            jitterMs = 0;
+            lossPercentage = 0;
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const TransportImpairment& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(applicationPercentage),
+            TOJSON_IMPL(jitterMs),
+            TOJSON_IMPL(lossPercentage)
+        };
+    }
+    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);
+    }
+
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(NsmNetworking)
+    /**
+     * @brief NsmNetworking
+     *
+     * Helper C++ class to serialize and de-serialize NsmNetworking JSON
+     * 
+     * Example: @include[doc] examples/NsmNetworking.json
+     *
+     */
+    class NsmNetworking : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(NsmNetworking)
+
+    public:        
+        std::string                         interfaceName;
+        NetworkAddress                      address;
+        int                                 ttl;
+        int                                 tos;
+        int                                 txOversend;
+        TransportImpairment                 rxImpairment;
+        TransportImpairment                 txImpairment;
+        std::string                         cryptoPassword;
+
+        NsmNetworking()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            interfaceName.clear();
+            address.clear();
+            ttl = 1;
+            tos = 56;
+            txOversend = 0;
+            rxImpairment.clear();
+            txImpairment.clear();
+            cryptoPassword.clear();
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const NsmNetworking& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(interfaceName),
+            TOJSON_IMPL(address),
+            TOJSON_IMPL(ttl),
+            TOJSON_IMPL(tos),
+            TOJSON_IMPL(txOversend),
+            TOJSON_IMPL(rxImpairment),
+            TOJSON_IMPL(txImpairment),
+            TOJSON_IMPL(cryptoPassword)
+        };
+    }
+    static void from_json(const nlohmann::json& j, NsmNetworking& p)
+    {
+        p.clear();
+        getOptional("interfaceName", p.interfaceName, j, EMPTY_STRING);
+        getOptional<NetworkAddress>("address", p.address, j);
+        getOptional<int>("ttl", p.ttl, j, 1);
+        getOptional<int>("tos", p.tos, j, 56);
+        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);
+    }
+
+
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(NsmConfiguration)
+    /**
+     * @brief NsmConfiguration
+     *
+     * Helper C++ class to serialize and de-serialize NsmConfiguration JSON
+     * 
+     * Example: @include[doc] examples/NsmConfiguration.json
+     *
+     */
+    class NsmConfiguration : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(NsmConfiguration)
+
+    public:
+
+        std::string                         id;
+        bool                                favorUptime;
+        NsmNetworking                       networking;
+        std::vector<std::string>            resources;
+        int                                 tokenStart;
+        int                                 tokenEnd;
+        int                                 intervalSecs;
+        int                                 transitionSecsFactor;
+
+        NsmConfiguration()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            id.clear();
+            favorUptime = false;
+            networking.clear();
+            resources.clear();
+            tokenStart = 1000000;
+            tokenEnd = 2000000;
+            intervalSecs = 1;
+            transitionSecsFactor = 3;
+        }
+    };
+
+    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)
+        };
+    }
+    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);
+        getOptional<std::vector<std::string>>("resources", p.resources, j);
+        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);
+    }
+
+
     //-----------------------------------------------------------
     JSON_SERIALIZED_CLASS(Rallypoint)
     /**
@@ -2550,55 +2754,6 @@ namespace AppConfigurationObjects
         getOptional("extra", p.extra, j);
     }
 
-    //-----------------------------------------------------------
-    JSON_SERIALIZED_CLASS(TransportImpairment)
-    /**
-     * @brief Description of a transport impairment
-     *
-     * Helper C++ class to serialize and de-serialize TransportImpairment JSON.
-     *
-     * Example: @include[doc] examples/TransportImpairment.json
-     *
-     */
-    class TransportImpairment : public ConfigurationObjectBase
-    {
-        IMPLEMENT_JSON_SERIALIZATION()
-        IMPLEMENT_JSON_DOCUMENTATION(NetworkDeviceDescriptor)
-
-    public:
-        int     applicationPercentage;
-        int     jitterMs;
-        int     lossPercentage;
-
-        TransportImpairment()
-        {
-            clear();
-        }
-
-        void clear()
-        {
-            applicationPercentage = 0;
-            jitterMs = 0;
-            lossPercentage = 0;
-        }
-    };
-
-    static void to_json(nlohmann::json& j, const TransportImpairment& p)
-    {
-        j = nlohmann::json{
-            TOJSON_IMPL(applicationPercentage),
-            TOJSON_IMPL(jitterMs),
-            TOJSON_IMPL(lossPercentage)
-        };
-    }
-    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);
-    }
-
     //-----------------------------------------------------------
     JSON_SERIALIZED_CLASS(TxAudio)
     /**
@@ -4054,13 +4209,13 @@ namespace AppConfigurationObjects
         std::string             nodeId;
 
         /* NOTE: Not serialized ! */
-        uint8_t                 _internal_binary_nodeId[MAX_NODE_ID_SIZE];
+        uint8_t                 _internal_binary_nodeId[ENGAGE_MAX_NODE_ID_SIZE];
 
         /** @brief [Optional] An alias */
         std::string             alias;
         
         /* NOTE: Not serialized ! */
-        uint8_t                 _internal_binary_alias[MAX_ALIAS_SIZE];
+        uint8_t                 _internal_binary_alias[ENGAGE_MAX_ALIAS_SIZE];
 
         Source()
         {
@@ -7536,6 +7691,48 @@ namespace AppConfigurationObjects
         getOptional<std::string>("runCmd", p.runCmd, j);
     }
 
+
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(RallypointWebsocketSettings)
+    /**
+     * @brief Defines settings for Rallypoint websockets functionality
+     *
+     * Example: @include[doc] examples/RallypointWebsocketSettings.json
+     *
+     */
+    class RallypointWebsocketSettings : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(RallypointWebsocketSettings)
+
+    public:
+        /** @brief Listen port (TCP).  Default is 8443 */
+        int                                     listenPort;
+
+        RallypointWebsocketSettings()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            listenPort = 8443;
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const RallypointWebsocketSettings& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(listenPort)
+        };
+    }
+    static void from_json(const nlohmann::json& j, RallypointWebsocketSettings& p)
+    {
+        p.clear();
+        getOptional<int>("listenPort", p.listenPort, j, 8443);
+    }
+
+
     //-----------------------------------------------------------
     JSON_SERIALIZED_CLASS(RallypointServer)
     /**
@@ -7553,7 +7750,7 @@ namespace AppConfigurationObjects
 
     public:
         /** @brief [Optional] Settings for the FIPS crypto. */
-        FipsCryptoSettings                         fipsCrypto;
+        FipsCryptoSettings                          fipsCrypto;
     
         /** @brief [Optional] Settings for the Rallypoint's watchdog. */
         WatchdogSettings                            watchdog;
@@ -7687,6 +7884,12 @@ namespace AppConfigurationObjects
         /** @brief [Optional] Array of behaviors for roundtrip times to peers */
         std::vector<RallypointRpRtTimingBehavior>   peerRtBehaviors;
 
+        /** @brief [Optional] Settings for websocket operation */
+        RallypointWebsocketSettings                 websocket;
+
+        /** @brief [Optional] Settings for NSM. */
+        NsmConfiguration                            nsm;
+
         RallypointServer()
         {
             clear();
@@ -7739,6 +7942,8 @@ namespace AppConfigurationObjects
             maxOutboundPeerConnectionIntervalDeltaSecs = 15;
             peerRtTestIntervalMs = 60000;
             peerRtBehaviors.clear();
+            websocket.clear();
+            nsm.clear();
         }
     };
 
@@ -7789,7 +7994,9 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(routeMap),
             TOJSON_IMPL(maxOutboundPeerConnectionIntervalDeltaSecs),
             TOJSON_IMPL(peerRtTestIntervalMs),
-            TOJSON_IMPL(peerRtBehaviors)
+            TOJSON_IMPL(peerRtBehaviors),
+            TOJSON_IMPL(websocket),
+            TOJSON_IMPL(nsm)
         };
     }
     static void from_json(const nlohmann::json& j, RallypointServer& p)
@@ -7840,6 +8047,8 @@ namespace AppConfigurationObjects
         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);
     }
 
     //-----------------------------------------------------------
@@ -7916,6 +8125,7 @@ namespace AppConfigurationObjects
         getOptional<uint32_t>("configurationVersion", p.configurationVersion, j, 0);
     }
 
+
     //-----------------------------------------------------------
     class TimelineEvent
     {
@@ -8358,52 +8568,140 @@ namespace AppConfigurationObjects
         getOptional<std::string>("fingerprint", p.fingerprint, j, EMPTY_STRING);
     }
 
+
     //-----------------------------------------------------------
-    JSON_SERIALIZED_CLASS(BridgeCreationDetail)
+    JSON_SERIALIZED_CLASS(RiffDescriptor)
     /**
-    * @brief Detailed information for a bridge creation
+    * @brief Helper class for serializing and deserializing the RiffDescriptor JSON
     *
-    * Helper C++ class to serialize and de-serialize BridgeCreationDetail JSON
+    * Helper C++ class to serialize and de-serialize RiffDescriptor JSON
     *
+    * Example: @include[doc] examples/RiffDescriptor.json
+    *
+    * @see TODO: engageGetRiffDescriptor
     */
-    class BridgeCreationDetail : public ConfigurationObjectBase
+    class RiffDescriptor : public ConfigurationObjectBase
     {
         IMPLEMENT_JSON_SERIALIZATION()
-        IMPLEMENT_WRAPPED_JSON_SERIALIZATION(BridgeCreationDetail)
-        IMPLEMENT_JSON_DOCUMENTATION(BridgeCreationDetail)
+        IMPLEMENT_JSON_DOCUMENTATION(RiffDescriptor)
 
     public:
-        /** @brief Creation status */
-        typedef enum
-        {
-            /** @brief Undefined */
-            csUndefined                         = 0,
+        /** @brief Name of the RIFF file. */
+        std::string                             file;
 
-            /** @brief Creation OK */
-            csOk                                = 1,
+        /** @brief True if the ECDSA signature is verified. */
+        bool                                    verified;
 
-            /** @brief Configuration JSON is empty */
-            csNoJson                            = -1,
+        /** @brief Number of audio channels */
+        int                                     channels;
 
-            /** @brief Bridge already exists */
-            csAlreadyExists                     = -3,
+        /** @brief Number of audio samples */
+        int                                     sampleCount;
 
-            /** @brief Invalid configuration */
-            csInvalidConfiguration              = -4,
+        /** @brief [Optional] Meta data associated with the file - typically a stringified JSON object. */
+        std::string                             meta;
 
-            /** @brief Invalid JSON */
-            csInvalidJson                       = -5,
+        /** @brief [Optional] X.509 certificate in PEM format used to sign the RIFF file. */
+        std::string                             certPem;
 
-            /** @brief Insufficient groups in bridge */
-            csInsufficientGroups                = -6,
+        /** @brief [Optional] X.509 certificate parsed into a CertificateDescriptor object. */
+        CertificateDescriptor                   certDescriptor;
 
-            /** @brief Too many groups in bridge */
-            csTooManyGroups                     = -7,
+        /** @brief [Optional] ECDSA signature */
+        std::string                             signature;
 
-            /** @brief Duplicate group in the same bridge */
-            csDuplicateGroup                    = -8,
+        RiffDescriptor()
+        {
+            clear();
+        }
 
-            /** @brief Duplicate group in the same bridge */
+        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)
+    /**
+    * @brief Detailed information for a bridge creation
+    *
+    * Helper C++ class to serialize and de-serialize BridgeCreationDetail JSON
+    *
+    */
+    class BridgeCreationDetail : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_WRAPPED_JSON_SERIALIZATION(BridgeCreationDetail)
+        IMPLEMENT_JSON_DOCUMENTATION(BridgeCreationDetail)
+
+    public:
+        /** @brief Creation status */
+        typedef enum
+        {
+            /** @brief Undefined */
+            csUndefined                         = 0,
+
+            /** @brief Creation OK */
+            csOk                                = 1,
+
+            /** @brief Configuration JSON is empty */
+            csNoJson                            = -1,
+
+            /** @brief Bridge already exists */
+            csAlreadyExists                     = -3,
+
+            /** @brief Invalid configuration */
+            csInvalidConfiguration              = -4,
+
+            /** @brief Invalid JSON */
+            csInvalidJson                       = -5,
+
+            /** @brief Insufficient groups in bridge */
+            csInsufficientGroups                = -6,
+
+            /** @brief Too many groups in bridge */
+            csTooManyGroups                     = -7,
+
+            /** @brief Duplicate group in the same bridge */
+            csDuplicateGroup                    = -8,
+
+            /** @brief Duplicate group in the same bridge */
             csLocalLoopDetected                 = -9,
         } CreationStatus_t;
 
@@ -9154,7 +9452,483 @@ namespace AppConfigurationObjects
         getOptional<uint64_t>("msToNextConnectionAttempt", p.msToNextConnectionAttempt, j, 0);
     }
 
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(TranslationSession)
+    /**
+    * @brief Translation session settings
+    *
+    * Helper C++ class to serialize and de-serialize TranslationSession JSON
+    *
+    * Example: @include[doc] examples/TranslationSession.json
+    *
+    * @see TODO: ConfigurationObjects::TranslationSession
+    */
+    class TranslationSession : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(TranslationSession)
+
+    public:
+        /** @brief ID */
+        std::string                 id;
+
+        /** @brief Name */
+        std::string                 name;
+
+        /** @brief List of group IDs to be included in the session */
+        std::vector<std::string>    groups;
+
+        /** @brief [Optional, Default: true] Enable the session */
+        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)
+    /**
+    * @brief Translation configuration
+    *
+    * Helper C++ class to serialize and de-serialize TranslationConfiguration JSON
+    *
+    * Example: @include[doc] examples/TranslationConfiguration.json
+    *
+    * @see TODO: ConfigurationObjects::TranslationConfiguration
+    */
+    class TranslationConfiguration : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(TranslationConfiguration)
+
+    public:
+        /** @brief Array of sessions in the configuration */
+        std::vector<TranslationSession>         sessions;
+
+        /** @brief Array of groups in the configuration */
+        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)
+    /**
+    * @brief TODO: Configuration for the translation server status report file
+    *
+    * Helper C++ class to serialize and de-serialize LingoServerStatusReportConfiguration JSON
+    *
+    * Example: @include[doc] examples/LingoServerStatusReportConfiguration.json
+    *
+    * @see RallypointServer
+    */
+    class LingoServerStatusReportConfiguration : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(LingoServerStatusReportConfiguration)
+
+    public:
+        /** File name to use for the status report. */
+        std::string                     fileName;
+
+        /** [Optional, Default: 30] The interval at which to write out the status report to file. */
+        int                             intervalSecs;
+
+        /** [Optional, Default: false] Indicates if status reporting is enabled. */
+        bool                            enabled;
+
+        /** [Optional, Default: null] Command to be executed every time the status report is produced. */
+        std::string                     runCmd;
+
+        /** [Optional, Default: false] Indicates whether to include details of each group. */
+        bool                            includeGroupDetail;
+
+        /** [Optional, Default: false] Indicates whether to include details of each session. */
+        bool                            includeSessionDetail;
+
+        /** [Optional, Default: false] Indicates whether to include details of each group in each session. */
+        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)
+    /**
+    * @brief Internal translator server settings
+    *
+    * These settings are used to configure internal parameters.
+    *
+    * Helper C++ class to serialize and de-serialize LingoServerInternals JSON
+    *
+    * Example: @include[doc] examples/LingoServerInternals.json
+    *
+    * @see engageInitialize, ConfigurationObjects::LingoServerConfiguration
+    */
+    class LingoServerInternals : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(LingoServerInternals)
+
+    public:
+        /** @brief [Optional] Settings for the watchdog. */
+        WatchdogSettings    watchdog;
+
+        /** @brief [Optional, Default: 1000] Interval at which to run the housekeeper thread. */
+        int                 housekeeperIntervalMs;
+
+        LingoServerInternals()
+        {
+            clear();
+        }
+
+        void clear()
+        {
+            watchdog.clear();
+            housekeeperIntervalMs = 1000;
+        }
+    };
+
+    static void to_json(nlohmann::json& j, const LingoServerInternals& p)
+    {
+        j = nlohmann::json{
+            TOJSON_IMPL(watchdog),
+            TOJSON_IMPL(housekeeperIntervalMs)
+        };
+    }
+    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);
+    }
+
+    //-----------------------------------------------------------
+    JSON_SERIALIZED_CLASS(LingoServerConfiguration)
+    /**
+    * @brief Configuration for the linguistics server
+    *
+    * Helper C++ class to serialize and de-serialize LingoServerConfiguration JSON
+    *
+    * Example: @include[doc] examples/LingoServerConfiguration.json
+    *
+    */
+    class LingoServerConfiguration : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(LingoServerConfiguration)
+
+    public:
+        /** @brief A unqiue identifier for the linguistics server */
+        std::string                                 id;
+
+        /** @brief Number of seconds between checks to see if the service configuration has been updated.  Default is 60.*/
+        int                                         serviceConfigurationFileCheckSecs;
+        
+        /** @brief Name of a file containing the linguistics configuration. */
+        std::string                                 lingoConfigurationFileName;
+
+        /** @brief Command-line to execute that returns a linguistics configuration */
+        std::string                                 lingoConfigurationFileCommand;
+
+        /** @brief Number of seconds between checks to see if the linguistics configuration has been updated.  Default is 60.*/
+        int                                         lingoConfigurationFileCheckSecs;
+
+        /** @brief Details for producing a status report. @see LingoServerStatusReportConfiguration */
+        LingoServerStatusReportConfiguration        statusReport;
+
+        /** @brief Details concerning the server's interaction with an external health-checker such as a load-balancer.  @see ExternalHealthCheckResponder */
+        ExternalHealthCheckResponder                externalHealthCheckResponder;
+
+        /** @brief Internal settings */
+        LingoServerInternals                        internals;
+
+        /** @brief Path to the certificate store */
+        std::string                                 certStoreFileName;
+
+        /** @brief Hex password for the certificate store (if any) */
+        std::string                                 certStorePasswordHex;
+
+        /** @brief The policy to be used for the underlying Engage Engine */
+        EnginePolicy                                enginePolicy;
+
+        /** @brief Name to use for signalling a configuration check */
+        std::string                                 configurationCheckSignalName;
+
+        /** @brief [Optional] Settings for the FIPS crypto. */
+        FipsCryptoSettings                          fipsCrypto;
+
+        /** @brief Address and port of the proxy */
+        NetworkAddress                              proxy;
+
+        /** @brief [Optional] Settings for NSM. */
+        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)
+    /**
+    * @brief Voice to voice session settings
+    *
+    * Helper C++ class to serialize and de-serialize VoiceToVoiceSession JSON
+    *
+    * Example: @include[doc] examples/VoiceToVoiceSession.json
+    *
+    * @see TODO: ConfigurationObjects::VoiceToVoiceSession
+    */
+    class VoiceToVoiceSession : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(VoiceToVoiceSession)
+
+    public:
+        /** @brief ID */
+        std::string                 id;
+
+        /** @brief Name */
+        std::string                 name;
+
+        /** @brief List of group IDs to be included in the session */
+        std::vector<std::string>    groups;
+
+        /** @brief [Optional, Default: true] Enable the session */
+        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)
+    /**
+    * @brief Lingo configuration
+    *
+    * Helper C++ class to serialize and de-serialize LingoConfiguration JSON
+    *
+    * Example: @include[doc] examples/LingoConfiguration.json
+    *
+    * @see TODO: ConfigurationObjects::LingoConfiguration
+    */
+    class LingoConfiguration : public ConfigurationObjectBase
+    {
+        IMPLEMENT_JSON_SERIALIZATION()
+        IMPLEMENT_JSON_DOCUMENTATION(LingoConfiguration)
+
+    public:
+        /** @brief Array of voiceToVoice sessions in the configuration */
+        std::vector<VoiceToVoiceSession>         voiceToVoiceSessions;
+
+        /** @brief Array of groups in the configuration */
+        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)
     /**
@@ -9302,7 +10076,7 @@ namespace AppConfigurationObjects
         IMPLEMENT_JSON_DOCUMENTATION(BridgingServerInternals)
 
     public:
-        /** @brief [Optional] Settings for the EAR's watchdog. */
+        /** @brief [Optional] Settings for the watchdog. */
         WatchdogSettings    watchdog;
 
         /** @brief [Optional, Default: 1000] Interval at which to run the housekeeper thread. */
@@ -9406,7 +10180,10 @@ namespace AppConfigurationObjects
         std::string                                 configurationCheckSignalName;
 
         /** @brief [Optional] Settings for the FIPS crypto. */
-        FipsCryptoSettings                         fipsCrypto;
+        FipsCryptoSettings                          fipsCrypto;
+
+        /** @brief [Optional] Settings for NSM. */
+        NsmConfiguration                            nsm;
 
         BridgingServerConfiguration()
         {
@@ -9429,6 +10206,7 @@ namespace AppConfigurationObjects
             enginePolicy.clear();
             configurationCheckSignalName = "rts.6cc0651.${id}";
             fipsCrypto.clear();
+            nsm.clear();
         }
     };
 
@@ -9448,7 +10226,8 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(certStorePasswordHex),
             TOJSON_IMPL(enginePolicy),
             TOJSON_IMPL(configurationCheckSignalName),
-            TOJSON_IMPL(fipsCrypto)
+            TOJSON_IMPL(fipsCrypto),
+            TOJSON_IMPL(nsm)
         };
     }
     static void from_json(const nlohmann::json& j, BridgingServerConfiguration& p)
@@ -9468,6 +10247,7 @@ namespace AppConfigurationObjects
         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);
     }
 
 
@@ -9688,6 +10468,9 @@ namespace AppConfigurationObjects
         /** @brief [Optional] Settings for the FIPS crypto. */
         FipsCryptoSettings                          fipsCrypto;
 
+        /** @brief [Optional] Settings for NSM. */
+        NsmConfiguration                            nsm;
+
         EarServerConfiguration()
         {
             clear();
@@ -9708,6 +10491,7 @@ namespace AppConfigurationObjects
             enginePolicy.clear();
             configurationCheckSignalName = "rts.9a164fa.${id}";
             fipsCrypto.clear();
+            nsm.clear();
         }
     };
 
@@ -9726,7 +10510,8 @@ namespace AppConfigurationObjects
             TOJSON_IMPL(certStorePasswordHex),
             TOJSON_IMPL(enginePolicy),
             TOJSON_IMPL(configurationCheckSignalName),
-            TOJSON_IMPL(fipsCrypto)
+            TOJSON_IMPL(fipsCrypto),
+            TOJSON_IMPL(nsm)
         };
     }
     static void from_json(const nlohmann::json& j, EarServerConfiguration& p)
@@ -9743,7 +10528,9 @@ namespace AppConfigurationObjects
         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<std::string>("configurationCheckSignalName", p.configurationCheckSignalName, j, "rts.9a164fa.${id}");
+        getOptional<FipsCryptoSettings>("fipsCrypto", p.fipsCrypto, j);
+        getOptional<NsmConfiguration>("nsm", p.nsm, j);
     }
 
     //-----------------------------------------------------------