diff --git a/src/FeaturizerPrep/SharedLibrary/GeneratedCode/SharedLibrary_RobustScalarFeaturizer.cpp b/src/FeaturizerPrep/SharedLibrary/GeneratedCode/SharedLibrary_RobustScalarFeaturizer.cpp
new file mode 100644
index 0000000..eb9ad98
--- /dev/null
+++ b/src/FeaturizerPrep/SharedLibrary/GeneratedCode/SharedLibrary_RobustScalarFeaturizer.cpp
@@ -0,0 +1,3130 @@
+/* ---------------------------------------------------------------------- */
+/* Copyright (c) Microsoft Corporation. All rights reserved.              */
+/* Licensed under the MIT License                                         */
+/* ---------------------------------------------------------------------- */
+#define DLL_EXPORT_COMPILE
+
+#include "SharedLibrary_RobustScalarFeaturizer.h"
+#include "SharedLibrary_PointerTable.h"
+
+#include "Archive.h"
+#include "RobustScalarFeaturizer.h"
+
+// These method(s) are defined in SharedLibrary_Common.cpp
+ErrorInfoHandle * CreateErrorInfo(std::exception const &ex);
+
+extern "C" {
+
+// I don't know why MSVC thinks that there is unreachable
+// code in these methods during release builds.
+#if (defined _MSC_VER)
+#   pragma warning(push)
+#   pragma warning(disable: 4702) // Unreachable code
+#endif
+
+/* ---------------------------------------------------------------------- */
+/* |                                                                      */
+/* |  RobustScalarFeaturizer <int8_t> */
+/* |                                                                      */
+/* ---------------------------------------------------------------------- */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_CreateEstimator(/*out*/ RobustScalarFeaturizer_int8_t_EstimatorHandle **ppHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        // No validation
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t>* pEstimator = new Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t>(std::make_shared<Microsoft::Featurizer::AnnotationMaps>(1));
+        size_t index(g_pointerTable.Add(pEstimator));
+        *ppHandle = reinterpret_cast<RobustScalarFeaturizer_int8_t_EstimatorHandle*>(index);
+
+
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_DestroyEstimator(/*in*/ RobustScalarFeaturizer_int8_t_EstimatorHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+        size_t index = reinterpret_cast<size_t>(pHandle);
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t> * pEstimator = g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t>>(index);
+        g_pointerTable.Remove(index);
+
+        delete pEstimator;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_IsTrainingComplete(/*in*/ RobustScalarFeaturizer_int8_t_EstimatorHandle *pHandle, /*out*/ bool *pIsTrainingComplete, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pIsTrainingComplete == nullptr) throw std::invalid_argument("'pIsTrainingComplete' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t> const & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t>>(reinterpret_cast<size_t>(pHandle)));
+
+
+        *pIsTrainingComplete = estimator.is_training_complete();
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_Fit(/*in*/ RobustScalarFeaturizer_int8_t_EstimatorHandle *pHandle, /*in*/ int8_t input, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+        // No validation
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t>>(reinterpret_cast<size_t>(pHandle)));
+
+
+        *pFitResult = static_cast<unsigned char>(estimator.fit(input));
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_FitBuffer(/*in*/ RobustScalarFeaturizer_int8_t_EstimatorHandle *pHandle, /*in*/ int8_t const * input_ptr, /*in*/ std::size_t input_items, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+
+        if(input_ptr == nullptr) throw std::invalid_argument("'input_ptr' is null");
+        if(input_items == 0) throw std::invalid_argument("'input_items' is 0");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t>>(reinterpret_cast<size_t>(pHandle)));
+
+        *pFitResult = static_cast<unsigned char>(estimator.fit(input_ptr, input_items));
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_CompleteTraining(/*in*/ RobustScalarFeaturizer_int8_t_EstimatorHandle *pHandle, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t>>(reinterpret_cast<size_t>(pHandle)));
+
+        *pFitResult = static_cast<unsigned char>(estimator.complete_training());
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_CreateTransformerFromEstimator(/*in*/ RobustScalarFeaturizer_int8_t_EstimatorHandle *pEstimatorHandle, /*out*/ RobustScalarFeaturizer_int8_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pEstimatorHandle == nullptr) throw std::invalid_argument("'pEstimatorHandle' is null");
+        if(ppTransformerHandle == nullptr) throw std::invalid_argument("'ppTransformerHandle' is null");
+
+
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t>>(reinterpret_cast<size_t>(pEstimatorHandle)));
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t>::TransformerType * pTransformer = reinterpret_cast<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t>::TransformerType*>(estimator.create_transformer().release());
+
+
+        size_t index = g_pointerTable.Add(pTransformer);
+        *ppTransformerHandle = reinterpret_cast<RobustScalarFeaturizer_int8_t_TransformerHandle*>(index);
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_CreateTransformerFromSavedData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ RobustScalarFeaturizer_int8_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pBuffer == nullptr) throw std::invalid_argument("'pBuffer' is null");
+        if(cBufferSize == 0) throw std::invalid_argument("'cBufferSize' is 0");
+        if(ppTransformerHandle == nullptr) throw std::invalid_argument("'ppTransformerHandle' is null");
+
+        Microsoft::Featurizer::Archive archive(pBuffer, cBufferSize);
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t>::TransformerType* pTransformer= (std::make_unique<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t>::TransformerType>(archive).release());
+
+        size_t index = g_pointerTable.Add(pTransformer);
+        *ppTransformerHandle = reinterpret_cast<RobustScalarFeaturizer_int8_t_TransformerHandle*>(index);
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_DestroyTransformer(/*in*/ RobustScalarFeaturizer_int8_t_TransformerHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+        size_t index = reinterpret_cast<size_t>(pHandle);
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t>::TransformerType* pTransformer = g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t>::TransformerType>(index);
+        g_pointerTable.Remove(index);
+
+
+        delete pTransformer;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_CreateTransformerSaveData(/*in*/ RobustScalarFeaturizer_int8_t_TransformerHandle *pHandle, /*out*/ unsigned char const **ppBuffer, /*out*/ std::size_t *pBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(ppBuffer == nullptr) throw std::invalid_argument("'ppBuffer' is null");
+        if(pBufferSize == nullptr) throw std::invalid_argument("'pBufferSize' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t>::TransformerType & transformer(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t>::TransformerType>(reinterpret_cast<size_t>(pHandle)));
+        Microsoft::Featurizer::Archive archive;
+
+        transformer.save(archive);
+
+        Microsoft::Featurizer::Archive::ByteArray const buffer(archive.commit());
+
+        unsigned char * new_buffer(new unsigned char[buffer.size()]);
+
+        std::copy(buffer.begin(), buffer.end(), new_buffer);
+
+        *ppBuffer = new_buffer;
+        *pBufferSize = buffer.size();
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_DestroyTransformerSaveData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pBuffer == nullptr) throw std::invalid_argument("'pBuffer' is null");
+        if(cBufferSize == 0) throw std::invalid_argument("'cBufferSize' is 0");
+
+        delete [] pBuffer;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_Transform(/*in*/ RobustScalarFeaturizer_int8_t_TransformerHandle *pHandle, /*in*/ int8_t input, /*out*/ float * output, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+
+        // No input validation
+        if(output == nullptr) throw std::invalid_argument("'output' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t>::TransformerType & transformer(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int8_t>::TransformerType>(reinterpret_cast<size_t>(pHandle)));
+
+        // Input
+        auto result(transformer.execute(input));
+
+        // Output
+        *output = result;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+/* ---------------------------------------------------------------------- */
+/* |                                                                      */
+/* |  RobustScalarFeaturizer <int16_t> */
+/* |                                                                      */
+/* ---------------------------------------------------------------------- */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_CreateEstimator(/*out*/ RobustScalarFeaturizer_int16_t_EstimatorHandle **ppHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        // No validation
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t>* pEstimator = new Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t>(std::make_shared<Microsoft::Featurizer::AnnotationMaps>(1));
+        size_t index(g_pointerTable.Add(pEstimator));
+        *ppHandle = reinterpret_cast<RobustScalarFeaturizer_int16_t_EstimatorHandle*>(index);
+
+
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_DestroyEstimator(/*in*/ RobustScalarFeaturizer_int16_t_EstimatorHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+        size_t index = reinterpret_cast<size_t>(pHandle);
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t> * pEstimator = g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t>>(index);
+        g_pointerTable.Remove(index);
+
+        delete pEstimator;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_IsTrainingComplete(/*in*/ RobustScalarFeaturizer_int16_t_EstimatorHandle *pHandle, /*out*/ bool *pIsTrainingComplete, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pIsTrainingComplete == nullptr) throw std::invalid_argument("'pIsTrainingComplete' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t> const & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t>>(reinterpret_cast<size_t>(pHandle)));
+
+
+        *pIsTrainingComplete = estimator.is_training_complete();
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_Fit(/*in*/ RobustScalarFeaturizer_int16_t_EstimatorHandle *pHandle, /*in*/ int16_t input, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+        // No validation
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t>>(reinterpret_cast<size_t>(pHandle)));
+
+
+        *pFitResult = static_cast<unsigned char>(estimator.fit(input));
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_FitBuffer(/*in*/ RobustScalarFeaturizer_int16_t_EstimatorHandle *pHandle, /*in*/ int16_t const * input_ptr, /*in*/ std::size_t input_items, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+
+        if(input_ptr == nullptr) throw std::invalid_argument("'input_ptr' is null");
+        if(input_items == 0) throw std::invalid_argument("'input_items' is 0");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t>>(reinterpret_cast<size_t>(pHandle)));
+
+        *pFitResult = static_cast<unsigned char>(estimator.fit(input_ptr, input_items));
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_CompleteTraining(/*in*/ RobustScalarFeaturizer_int16_t_EstimatorHandle *pHandle, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t>>(reinterpret_cast<size_t>(pHandle)));
+
+        *pFitResult = static_cast<unsigned char>(estimator.complete_training());
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_CreateTransformerFromEstimator(/*in*/ RobustScalarFeaturizer_int16_t_EstimatorHandle *pEstimatorHandle, /*out*/ RobustScalarFeaturizer_int16_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pEstimatorHandle == nullptr) throw std::invalid_argument("'pEstimatorHandle' is null");
+        if(ppTransformerHandle == nullptr) throw std::invalid_argument("'ppTransformerHandle' is null");
+
+
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t>>(reinterpret_cast<size_t>(pEstimatorHandle)));
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t>::TransformerType * pTransformer = reinterpret_cast<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t>::TransformerType*>(estimator.create_transformer().release());
+
+
+        size_t index = g_pointerTable.Add(pTransformer);
+        *ppTransformerHandle = reinterpret_cast<RobustScalarFeaturizer_int16_t_TransformerHandle*>(index);
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_CreateTransformerFromSavedData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ RobustScalarFeaturizer_int16_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pBuffer == nullptr) throw std::invalid_argument("'pBuffer' is null");
+        if(cBufferSize == 0) throw std::invalid_argument("'cBufferSize' is 0");
+        if(ppTransformerHandle == nullptr) throw std::invalid_argument("'ppTransformerHandle' is null");
+
+        Microsoft::Featurizer::Archive archive(pBuffer, cBufferSize);
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t>::TransformerType* pTransformer= (std::make_unique<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t>::TransformerType>(archive).release());
+
+        size_t index = g_pointerTable.Add(pTransformer);
+        *ppTransformerHandle = reinterpret_cast<RobustScalarFeaturizer_int16_t_TransformerHandle*>(index);
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_DestroyTransformer(/*in*/ RobustScalarFeaturizer_int16_t_TransformerHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+        size_t index = reinterpret_cast<size_t>(pHandle);
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t>::TransformerType* pTransformer = g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t>::TransformerType>(index);
+        g_pointerTable.Remove(index);
+
+
+        delete pTransformer;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_CreateTransformerSaveData(/*in*/ RobustScalarFeaturizer_int16_t_TransformerHandle *pHandle, /*out*/ unsigned char const **ppBuffer, /*out*/ std::size_t *pBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(ppBuffer == nullptr) throw std::invalid_argument("'ppBuffer' is null");
+        if(pBufferSize == nullptr) throw std::invalid_argument("'pBufferSize' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t>::TransformerType & transformer(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t>::TransformerType>(reinterpret_cast<size_t>(pHandle)));
+        Microsoft::Featurizer::Archive archive;
+
+        transformer.save(archive);
+
+        Microsoft::Featurizer::Archive::ByteArray const buffer(archive.commit());
+
+        unsigned char * new_buffer(new unsigned char[buffer.size()]);
+
+        std::copy(buffer.begin(), buffer.end(), new_buffer);
+
+        *ppBuffer = new_buffer;
+        *pBufferSize = buffer.size();
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_DestroyTransformerSaveData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pBuffer == nullptr) throw std::invalid_argument("'pBuffer' is null");
+        if(cBufferSize == 0) throw std::invalid_argument("'cBufferSize' is 0");
+
+        delete [] pBuffer;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_Transform(/*in*/ RobustScalarFeaturizer_int16_t_TransformerHandle *pHandle, /*in*/ int16_t input, /*out*/ float * output, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+
+        // No input validation
+        if(output == nullptr) throw std::invalid_argument("'output' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t>::TransformerType & transformer(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int16_t>::TransformerType>(reinterpret_cast<size_t>(pHandle)));
+
+        // Input
+        auto result(transformer.execute(input));
+
+        // Output
+        *output = result;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+/* ---------------------------------------------------------------------- */
+/* |                                                                      */
+/* |  RobustScalarFeaturizer <uint8_t> */
+/* |                                                                      */
+/* ---------------------------------------------------------------------- */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_CreateEstimator(/*out*/ RobustScalarFeaturizer_uint8_t_EstimatorHandle **ppHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        // No validation
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t>* pEstimator = new Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t>(std::make_shared<Microsoft::Featurizer::AnnotationMaps>(1));
+        size_t index(g_pointerTable.Add(pEstimator));
+        *ppHandle = reinterpret_cast<RobustScalarFeaturizer_uint8_t_EstimatorHandle*>(index);
+
+
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_DestroyEstimator(/*in*/ RobustScalarFeaturizer_uint8_t_EstimatorHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+        size_t index = reinterpret_cast<size_t>(pHandle);
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t> * pEstimator = g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t>>(index);
+        g_pointerTable.Remove(index);
+
+        delete pEstimator;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_IsTrainingComplete(/*in*/ RobustScalarFeaturizer_uint8_t_EstimatorHandle *pHandle, /*out*/ bool *pIsTrainingComplete, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pIsTrainingComplete == nullptr) throw std::invalid_argument("'pIsTrainingComplete' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t> const & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t>>(reinterpret_cast<size_t>(pHandle)));
+
+
+        *pIsTrainingComplete = estimator.is_training_complete();
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_Fit(/*in*/ RobustScalarFeaturizer_uint8_t_EstimatorHandle *pHandle, /*in*/ uint8_t input, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+        // No validation
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t>>(reinterpret_cast<size_t>(pHandle)));
+
+
+        *pFitResult = static_cast<unsigned char>(estimator.fit(input));
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_FitBuffer(/*in*/ RobustScalarFeaturizer_uint8_t_EstimatorHandle *pHandle, /*in*/ uint8_t const * input_ptr, /*in*/ std::size_t input_items, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+
+        if(input_ptr == nullptr) throw std::invalid_argument("'input_ptr' is null");
+        if(input_items == 0) throw std::invalid_argument("'input_items' is 0");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t>>(reinterpret_cast<size_t>(pHandle)));
+
+        *pFitResult = static_cast<unsigned char>(estimator.fit(input_ptr, input_items));
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_CompleteTraining(/*in*/ RobustScalarFeaturizer_uint8_t_EstimatorHandle *pHandle, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t>>(reinterpret_cast<size_t>(pHandle)));
+
+        *pFitResult = static_cast<unsigned char>(estimator.complete_training());
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_CreateTransformerFromEstimator(/*in*/ RobustScalarFeaturizer_uint8_t_EstimatorHandle *pEstimatorHandle, /*out*/ RobustScalarFeaturizer_uint8_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pEstimatorHandle == nullptr) throw std::invalid_argument("'pEstimatorHandle' is null");
+        if(ppTransformerHandle == nullptr) throw std::invalid_argument("'ppTransformerHandle' is null");
+
+
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t>>(reinterpret_cast<size_t>(pEstimatorHandle)));
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t>::TransformerType * pTransformer = reinterpret_cast<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t>::TransformerType*>(estimator.create_transformer().release());
+
+
+        size_t index = g_pointerTable.Add(pTransformer);
+        *ppTransformerHandle = reinterpret_cast<RobustScalarFeaturizer_uint8_t_TransformerHandle*>(index);
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_CreateTransformerFromSavedData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ RobustScalarFeaturizer_uint8_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pBuffer == nullptr) throw std::invalid_argument("'pBuffer' is null");
+        if(cBufferSize == 0) throw std::invalid_argument("'cBufferSize' is 0");
+        if(ppTransformerHandle == nullptr) throw std::invalid_argument("'ppTransformerHandle' is null");
+
+        Microsoft::Featurizer::Archive archive(pBuffer, cBufferSize);
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t>::TransformerType* pTransformer= (std::make_unique<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t>::TransformerType>(archive).release());
+
+        size_t index = g_pointerTable.Add(pTransformer);
+        *ppTransformerHandle = reinterpret_cast<RobustScalarFeaturizer_uint8_t_TransformerHandle*>(index);
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_DestroyTransformer(/*in*/ RobustScalarFeaturizer_uint8_t_TransformerHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+        size_t index = reinterpret_cast<size_t>(pHandle);
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t>::TransformerType* pTransformer = g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t>::TransformerType>(index);
+        g_pointerTable.Remove(index);
+
+
+        delete pTransformer;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_CreateTransformerSaveData(/*in*/ RobustScalarFeaturizer_uint8_t_TransformerHandle *pHandle, /*out*/ unsigned char const **ppBuffer, /*out*/ std::size_t *pBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(ppBuffer == nullptr) throw std::invalid_argument("'ppBuffer' is null");
+        if(pBufferSize == nullptr) throw std::invalid_argument("'pBufferSize' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t>::TransformerType & transformer(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t>::TransformerType>(reinterpret_cast<size_t>(pHandle)));
+        Microsoft::Featurizer::Archive archive;
+
+        transformer.save(archive);
+
+        Microsoft::Featurizer::Archive::ByteArray const buffer(archive.commit());
+
+        unsigned char * new_buffer(new unsigned char[buffer.size()]);
+
+        std::copy(buffer.begin(), buffer.end(), new_buffer);
+
+        *ppBuffer = new_buffer;
+        *pBufferSize = buffer.size();
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_DestroyTransformerSaveData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pBuffer == nullptr) throw std::invalid_argument("'pBuffer' is null");
+        if(cBufferSize == 0) throw std::invalid_argument("'cBufferSize' is 0");
+
+        delete [] pBuffer;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_Transform(/*in*/ RobustScalarFeaturizer_uint8_t_TransformerHandle *pHandle, /*in*/ uint8_t input, /*out*/ float * output, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+
+        // No input validation
+        if(output == nullptr) throw std::invalid_argument("'output' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t>::TransformerType & transformer(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint8_t>::TransformerType>(reinterpret_cast<size_t>(pHandle)));
+
+        // Input
+        auto result(transformer.execute(input));
+
+        // Output
+        *output = result;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+/* ---------------------------------------------------------------------- */
+/* |                                                                      */
+/* |  RobustScalarFeaturizer <uint16_t> */
+/* |                                                                      */
+/* ---------------------------------------------------------------------- */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_CreateEstimator(/*out*/ RobustScalarFeaturizer_uint16_t_EstimatorHandle **ppHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        // No validation
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t>* pEstimator = new Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t>(std::make_shared<Microsoft::Featurizer::AnnotationMaps>(1));
+        size_t index(g_pointerTable.Add(pEstimator));
+        *ppHandle = reinterpret_cast<RobustScalarFeaturizer_uint16_t_EstimatorHandle*>(index);
+
+
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_DestroyEstimator(/*in*/ RobustScalarFeaturizer_uint16_t_EstimatorHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+        size_t index = reinterpret_cast<size_t>(pHandle);
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t> * pEstimator = g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t>>(index);
+        g_pointerTable.Remove(index);
+
+        delete pEstimator;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_IsTrainingComplete(/*in*/ RobustScalarFeaturizer_uint16_t_EstimatorHandle *pHandle, /*out*/ bool *pIsTrainingComplete, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pIsTrainingComplete == nullptr) throw std::invalid_argument("'pIsTrainingComplete' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t> const & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t>>(reinterpret_cast<size_t>(pHandle)));
+
+
+        *pIsTrainingComplete = estimator.is_training_complete();
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_Fit(/*in*/ RobustScalarFeaturizer_uint16_t_EstimatorHandle *pHandle, /*in*/ uint16_t input, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+        // No validation
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t>>(reinterpret_cast<size_t>(pHandle)));
+
+
+        *pFitResult = static_cast<unsigned char>(estimator.fit(input));
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_FitBuffer(/*in*/ RobustScalarFeaturizer_uint16_t_EstimatorHandle *pHandle, /*in*/ uint16_t const * input_ptr, /*in*/ std::size_t input_items, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+
+        if(input_ptr == nullptr) throw std::invalid_argument("'input_ptr' is null");
+        if(input_items == 0) throw std::invalid_argument("'input_items' is 0");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t>>(reinterpret_cast<size_t>(pHandle)));
+
+        *pFitResult = static_cast<unsigned char>(estimator.fit(input_ptr, input_items));
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_CompleteTraining(/*in*/ RobustScalarFeaturizer_uint16_t_EstimatorHandle *pHandle, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t>>(reinterpret_cast<size_t>(pHandle)));
+
+        *pFitResult = static_cast<unsigned char>(estimator.complete_training());
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_CreateTransformerFromEstimator(/*in*/ RobustScalarFeaturizer_uint16_t_EstimatorHandle *pEstimatorHandle, /*out*/ RobustScalarFeaturizer_uint16_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pEstimatorHandle == nullptr) throw std::invalid_argument("'pEstimatorHandle' is null");
+        if(ppTransformerHandle == nullptr) throw std::invalid_argument("'ppTransformerHandle' is null");
+
+
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t>>(reinterpret_cast<size_t>(pEstimatorHandle)));
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t>::TransformerType * pTransformer = reinterpret_cast<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t>::TransformerType*>(estimator.create_transformer().release());
+
+
+        size_t index = g_pointerTable.Add(pTransformer);
+        *ppTransformerHandle = reinterpret_cast<RobustScalarFeaturizer_uint16_t_TransformerHandle*>(index);
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_CreateTransformerFromSavedData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ RobustScalarFeaturizer_uint16_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pBuffer == nullptr) throw std::invalid_argument("'pBuffer' is null");
+        if(cBufferSize == 0) throw std::invalid_argument("'cBufferSize' is 0");
+        if(ppTransformerHandle == nullptr) throw std::invalid_argument("'ppTransformerHandle' is null");
+
+        Microsoft::Featurizer::Archive archive(pBuffer, cBufferSize);
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t>::TransformerType* pTransformer= (std::make_unique<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t>::TransformerType>(archive).release());
+
+        size_t index = g_pointerTable.Add(pTransformer);
+        *ppTransformerHandle = reinterpret_cast<RobustScalarFeaturizer_uint16_t_TransformerHandle*>(index);
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_DestroyTransformer(/*in*/ RobustScalarFeaturizer_uint16_t_TransformerHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+        size_t index = reinterpret_cast<size_t>(pHandle);
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t>::TransformerType* pTransformer = g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t>::TransformerType>(index);
+        g_pointerTable.Remove(index);
+
+
+        delete pTransformer;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_CreateTransformerSaveData(/*in*/ RobustScalarFeaturizer_uint16_t_TransformerHandle *pHandle, /*out*/ unsigned char const **ppBuffer, /*out*/ std::size_t *pBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(ppBuffer == nullptr) throw std::invalid_argument("'ppBuffer' is null");
+        if(pBufferSize == nullptr) throw std::invalid_argument("'pBufferSize' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t>::TransformerType & transformer(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t>::TransformerType>(reinterpret_cast<size_t>(pHandle)));
+        Microsoft::Featurizer::Archive archive;
+
+        transformer.save(archive);
+
+        Microsoft::Featurizer::Archive::ByteArray const buffer(archive.commit());
+
+        unsigned char * new_buffer(new unsigned char[buffer.size()]);
+
+        std::copy(buffer.begin(), buffer.end(), new_buffer);
+
+        *ppBuffer = new_buffer;
+        *pBufferSize = buffer.size();
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_DestroyTransformerSaveData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pBuffer == nullptr) throw std::invalid_argument("'pBuffer' is null");
+        if(cBufferSize == 0) throw std::invalid_argument("'cBufferSize' is 0");
+
+        delete [] pBuffer;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_Transform(/*in*/ RobustScalarFeaturizer_uint16_t_TransformerHandle *pHandle, /*in*/ uint16_t input, /*out*/ float * output, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+
+        // No input validation
+        if(output == nullptr) throw std::invalid_argument("'output' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t>::TransformerType & transformer(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint16_t>::TransformerType>(reinterpret_cast<size_t>(pHandle)));
+
+        // Input
+        auto result(transformer.execute(input));
+
+        // Output
+        *output = result;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+/* ---------------------------------------------------------------------- */
+/* |                                                                      */
+/* |  RobustScalarFeaturizer <float_t> */
+/* |                                                                      */
+/* ---------------------------------------------------------------------- */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_CreateEstimator(/*out*/ RobustScalarFeaturizer_float_t_EstimatorHandle **ppHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        // No validation
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t>* pEstimator = new Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t>(std::make_shared<Microsoft::Featurizer::AnnotationMaps>(1));
+        size_t index(g_pointerTable.Add(pEstimator));
+        *ppHandle = reinterpret_cast<RobustScalarFeaturizer_float_t_EstimatorHandle*>(index);
+
+
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_DestroyEstimator(/*in*/ RobustScalarFeaturizer_float_t_EstimatorHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+        size_t index = reinterpret_cast<size_t>(pHandle);
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t> * pEstimator = g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t>>(index);
+        g_pointerTable.Remove(index);
+
+        delete pEstimator;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_IsTrainingComplete(/*in*/ RobustScalarFeaturizer_float_t_EstimatorHandle *pHandle, /*out*/ bool *pIsTrainingComplete, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pIsTrainingComplete == nullptr) throw std::invalid_argument("'pIsTrainingComplete' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t> const & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t>>(reinterpret_cast<size_t>(pHandle)));
+
+
+        *pIsTrainingComplete = estimator.is_training_complete();
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_Fit(/*in*/ RobustScalarFeaturizer_float_t_EstimatorHandle *pHandle, /*in*/ float input, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+        // No validation
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t>>(reinterpret_cast<size_t>(pHandle)));
+
+
+        *pFitResult = static_cast<unsigned char>(estimator.fit(input));
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_FitBuffer(/*in*/ RobustScalarFeaturizer_float_t_EstimatorHandle *pHandle, /*in*/ float const * input_ptr, /*in*/ std::size_t input_items, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+
+        if(input_ptr == nullptr) throw std::invalid_argument("'input_ptr' is null");
+        if(input_items == 0) throw std::invalid_argument("'input_items' is 0");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t>>(reinterpret_cast<size_t>(pHandle)));
+
+        *pFitResult = static_cast<unsigned char>(estimator.fit(input_ptr, input_items));
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_CompleteTraining(/*in*/ RobustScalarFeaturizer_float_t_EstimatorHandle *pHandle, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t>>(reinterpret_cast<size_t>(pHandle)));
+
+        *pFitResult = static_cast<unsigned char>(estimator.complete_training());
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_CreateTransformerFromEstimator(/*in*/ RobustScalarFeaturizer_float_t_EstimatorHandle *pEstimatorHandle, /*out*/ RobustScalarFeaturizer_float_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pEstimatorHandle == nullptr) throw std::invalid_argument("'pEstimatorHandle' is null");
+        if(ppTransformerHandle == nullptr) throw std::invalid_argument("'ppTransformerHandle' is null");
+
+
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t>>(reinterpret_cast<size_t>(pEstimatorHandle)));
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t>::TransformerType * pTransformer = reinterpret_cast<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t>::TransformerType*>(estimator.create_transformer().release());
+
+
+        size_t index = g_pointerTable.Add(pTransformer);
+        *ppTransformerHandle = reinterpret_cast<RobustScalarFeaturizer_float_t_TransformerHandle*>(index);
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_CreateTransformerFromSavedData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ RobustScalarFeaturizer_float_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pBuffer == nullptr) throw std::invalid_argument("'pBuffer' is null");
+        if(cBufferSize == 0) throw std::invalid_argument("'cBufferSize' is 0");
+        if(ppTransformerHandle == nullptr) throw std::invalid_argument("'ppTransformerHandle' is null");
+
+        Microsoft::Featurizer::Archive archive(pBuffer, cBufferSize);
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t>::TransformerType* pTransformer= (std::make_unique<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t>::TransformerType>(archive).release());
+
+        size_t index = g_pointerTable.Add(pTransformer);
+        *ppTransformerHandle = reinterpret_cast<RobustScalarFeaturizer_float_t_TransformerHandle*>(index);
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_DestroyTransformer(/*in*/ RobustScalarFeaturizer_float_t_TransformerHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+        size_t index = reinterpret_cast<size_t>(pHandle);
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t>::TransformerType* pTransformer = g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t>::TransformerType>(index);
+        g_pointerTable.Remove(index);
+
+
+        delete pTransformer;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_CreateTransformerSaveData(/*in*/ RobustScalarFeaturizer_float_t_TransformerHandle *pHandle, /*out*/ unsigned char const **ppBuffer, /*out*/ std::size_t *pBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(ppBuffer == nullptr) throw std::invalid_argument("'ppBuffer' is null");
+        if(pBufferSize == nullptr) throw std::invalid_argument("'pBufferSize' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t>::TransformerType & transformer(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t>::TransformerType>(reinterpret_cast<size_t>(pHandle)));
+        Microsoft::Featurizer::Archive archive;
+
+        transformer.save(archive);
+
+        Microsoft::Featurizer::Archive::ByteArray const buffer(archive.commit());
+
+        unsigned char * new_buffer(new unsigned char[buffer.size()]);
+
+        std::copy(buffer.begin(), buffer.end(), new_buffer);
+
+        *ppBuffer = new_buffer;
+        *pBufferSize = buffer.size();
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_DestroyTransformerSaveData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pBuffer == nullptr) throw std::invalid_argument("'pBuffer' is null");
+        if(cBufferSize == 0) throw std::invalid_argument("'cBufferSize' is 0");
+
+        delete [] pBuffer;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_Transform(/*in*/ RobustScalarFeaturizer_float_t_TransformerHandle *pHandle, /*in*/ float input, /*out*/ float * output, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+
+        // No input validation
+        if(output == nullptr) throw std::invalid_argument("'output' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t>::TransformerType & transformer(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::float_t>::TransformerType>(reinterpret_cast<size_t>(pHandle)));
+
+        // Input
+        auto result(transformer.execute(input));
+
+        // Output
+        *output = result;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+/* ---------------------------------------------------------------------- */
+/* |                                                                      */
+/* |  RobustScalarFeaturizer <int32_t> */
+/* |                                                                      */
+/* ---------------------------------------------------------------------- */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_CreateEstimator(/*out*/ RobustScalarFeaturizer_int32_t_EstimatorHandle **ppHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        // No validation
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t>* pEstimator = new Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t>(std::make_shared<Microsoft::Featurizer::AnnotationMaps>(1));
+        size_t index(g_pointerTable.Add(pEstimator));
+        *ppHandle = reinterpret_cast<RobustScalarFeaturizer_int32_t_EstimatorHandle*>(index);
+
+
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_DestroyEstimator(/*in*/ RobustScalarFeaturizer_int32_t_EstimatorHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+        size_t index = reinterpret_cast<size_t>(pHandle);
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t> * pEstimator = g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t>>(index);
+        g_pointerTable.Remove(index);
+
+        delete pEstimator;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_IsTrainingComplete(/*in*/ RobustScalarFeaturizer_int32_t_EstimatorHandle *pHandle, /*out*/ bool *pIsTrainingComplete, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pIsTrainingComplete == nullptr) throw std::invalid_argument("'pIsTrainingComplete' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t> const & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t>>(reinterpret_cast<size_t>(pHandle)));
+
+
+        *pIsTrainingComplete = estimator.is_training_complete();
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_Fit(/*in*/ RobustScalarFeaturizer_int32_t_EstimatorHandle *pHandle, /*in*/ int32_t input, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+        // No validation
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t>>(reinterpret_cast<size_t>(pHandle)));
+
+
+        *pFitResult = static_cast<unsigned char>(estimator.fit(input));
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_FitBuffer(/*in*/ RobustScalarFeaturizer_int32_t_EstimatorHandle *pHandle, /*in*/ int32_t const * input_ptr, /*in*/ std::size_t input_items, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+
+        if(input_ptr == nullptr) throw std::invalid_argument("'input_ptr' is null");
+        if(input_items == 0) throw std::invalid_argument("'input_items' is 0");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t>>(reinterpret_cast<size_t>(pHandle)));
+
+        *pFitResult = static_cast<unsigned char>(estimator.fit(input_ptr, input_items));
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_CompleteTraining(/*in*/ RobustScalarFeaturizer_int32_t_EstimatorHandle *pHandle, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t>>(reinterpret_cast<size_t>(pHandle)));
+
+        *pFitResult = static_cast<unsigned char>(estimator.complete_training());
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_CreateTransformerFromEstimator(/*in*/ RobustScalarFeaturizer_int32_t_EstimatorHandle *pEstimatorHandle, /*out*/ RobustScalarFeaturizer_int32_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pEstimatorHandle == nullptr) throw std::invalid_argument("'pEstimatorHandle' is null");
+        if(ppTransformerHandle == nullptr) throw std::invalid_argument("'ppTransformerHandle' is null");
+
+
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t>>(reinterpret_cast<size_t>(pEstimatorHandle)));
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t>::TransformerType * pTransformer = reinterpret_cast<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t>::TransformerType*>(estimator.create_transformer().release());
+
+
+        size_t index = g_pointerTable.Add(pTransformer);
+        *ppTransformerHandle = reinterpret_cast<RobustScalarFeaturizer_int32_t_TransformerHandle*>(index);
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_CreateTransformerFromSavedData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ RobustScalarFeaturizer_int32_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pBuffer == nullptr) throw std::invalid_argument("'pBuffer' is null");
+        if(cBufferSize == 0) throw std::invalid_argument("'cBufferSize' is 0");
+        if(ppTransformerHandle == nullptr) throw std::invalid_argument("'ppTransformerHandle' is null");
+
+        Microsoft::Featurizer::Archive archive(pBuffer, cBufferSize);
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t>::TransformerType* pTransformer= (std::make_unique<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t>::TransformerType>(archive).release());
+
+        size_t index = g_pointerTable.Add(pTransformer);
+        *ppTransformerHandle = reinterpret_cast<RobustScalarFeaturizer_int32_t_TransformerHandle*>(index);
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_DestroyTransformer(/*in*/ RobustScalarFeaturizer_int32_t_TransformerHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+        size_t index = reinterpret_cast<size_t>(pHandle);
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t>::TransformerType* pTransformer = g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t>::TransformerType>(index);
+        g_pointerTable.Remove(index);
+
+
+        delete pTransformer;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_CreateTransformerSaveData(/*in*/ RobustScalarFeaturizer_int32_t_TransformerHandle *pHandle, /*out*/ unsigned char const **ppBuffer, /*out*/ std::size_t *pBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(ppBuffer == nullptr) throw std::invalid_argument("'ppBuffer' is null");
+        if(pBufferSize == nullptr) throw std::invalid_argument("'pBufferSize' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t>::TransformerType & transformer(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t>::TransformerType>(reinterpret_cast<size_t>(pHandle)));
+        Microsoft::Featurizer::Archive archive;
+
+        transformer.save(archive);
+
+        Microsoft::Featurizer::Archive::ByteArray const buffer(archive.commit());
+
+        unsigned char * new_buffer(new unsigned char[buffer.size()]);
+
+        std::copy(buffer.begin(), buffer.end(), new_buffer);
+
+        *ppBuffer = new_buffer;
+        *pBufferSize = buffer.size();
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_DestroyTransformerSaveData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pBuffer == nullptr) throw std::invalid_argument("'pBuffer' is null");
+        if(cBufferSize == 0) throw std::invalid_argument("'cBufferSize' is 0");
+
+        delete [] pBuffer;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_Transform(/*in*/ RobustScalarFeaturizer_int32_t_TransformerHandle *pHandle, /*in*/ int32_t input, /*out*/ double * output, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+
+        // No input validation
+        if(output == nullptr) throw std::invalid_argument("'output' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t>::TransformerType & transformer(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int32_t>::TransformerType>(reinterpret_cast<size_t>(pHandle)));
+
+        // Input
+        auto result(transformer.execute(input));
+
+        // Output
+        *output = result;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+/* ---------------------------------------------------------------------- */
+/* |                                                                      */
+/* |  RobustScalarFeaturizer <int64_t> */
+/* |                                                                      */
+/* ---------------------------------------------------------------------- */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_CreateEstimator(/*out*/ RobustScalarFeaturizer_int64_t_EstimatorHandle **ppHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        // No validation
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t>* pEstimator = new Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t>(std::make_shared<Microsoft::Featurizer::AnnotationMaps>(1));
+        size_t index(g_pointerTable.Add(pEstimator));
+        *ppHandle = reinterpret_cast<RobustScalarFeaturizer_int64_t_EstimatorHandle*>(index);
+
+
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_DestroyEstimator(/*in*/ RobustScalarFeaturizer_int64_t_EstimatorHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+        size_t index = reinterpret_cast<size_t>(pHandle);
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t> * pEstimator = g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t>>(index);
+        g_pointerTable.Remove(index);
+
+        delete pEstimator;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_IsTrainingComplete(/*in*/ RobustScalarFeaturizer_int64_t_EstimatorHandle *pHandle, /*out*/ bool *pIsTrainingComplete, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pIsTrainingComplete == nullptr) throw std::invalid_argument("'pIsTrainingComplete' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t> const & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t>>(reinterpret_cast<size_t>(pHandle)));
+
+
+        *pIsTrainingComplete = estimator.is_training_complete();
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_Fit(/*in*/ RobustScalarFeaturizer_int64_t_EstimatorHandle *pHandle, /*in*/ int64_t input, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+        // No validation
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t>>(reinterpret_cast<size_t>(pHandle)));
+
+
+        *pFitResult = static_cast<unsigned char>(estimator.fit(input));
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_FitBuffer(/*in*/ RobustScalarFeaturizer_int64_t_EstimatorHandle *pHandle, /*in*/ int64_t const * input_ptr, /*in*/ std::size_t input_items, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+
+        if(input_ptr == nullptr) throw std::invalid_argument("'input_ptr' is null");
+        if(input_items == 0) throw std::invalid_argument("'input_items' is 0");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t>>(reinterpret_cast<size_t>(pHandle)));
+
+        *pFitResult = static_cast<unsigned char>(estimator.fit(input_ptr, input_items));
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_CompleteTraining(/*in*/ RobustScalarFeaturizer_int64_t_EstimatorHandle *pHandle, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t>>(reinterpret_cast<size_t>(pHandle)));
+
+        *pFitResult = static_cast<unsigned char>(estimator.complete_training());
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_CreateTransformerFromEstimator(/*in*/ RobustScalarFeaturizer_int64_t_EstimatorHandle *pEstimatorHandle, /*out*/ RobustScalarFeaturizer_int64_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pEstimatorHandle == nullptr) throw std::invalid_argument("'pEstimatorHandle' is null");
+        if(ppTransformerHandle == nullptr) throw std::invalid_argument("'ppTransformerHandle' is null");
+
+
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t>>(reinterpret_cast<size_t>(pEstimatorHandle)));
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t>::TransformerType * pTransformer = reinterpret_cast<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t>::TransformerType*>(estimator.create_transformer().release());
+
+
+        size_t index = g_pointerTable.Add(pTransformer);
+        *ppTransformerHandle = reinterpret_cast<RobustScalarFeaturizer_int64_t_TransformerHandle*>(index);
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_CreateTransformerFromSavedData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ RobustScalarFeaturizer_int64_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pBuffer == nullptr) throw std::invalid_argument("'pBuffer' is null");
+        if(cBufferSize == 0) throw std::invalid_argument("'cBufferSize' is 0");
+        if(ppTransformerHandle == nullptr) throw std::invalid_argument("'ppTransformerHandle' is null");
+
+        Microsoft::Featurizer::Archive archive(pBuffer, cBufferSize);
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t>::TransformerType* pTransformer= (std::make_unique<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t>::TransformerType>(archive).release());
+
+        size_t index = g_pointerTable.Add(pTransformer);
+        *ppTransformerHandle = reinterpret_cast<RobustScalarFeaturizer_int64_t_TransformerHandle*>(index);
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_DestroyTransformer(/*in*/ RobustScalarFeaturizer_int64_t_TransformerHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+        size_t index = reinterpret_cast<size_t>(pHandle);
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t>::TransformerType* pTransformer = g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t>::TransformerType>(index);
+        g_pointerTable.Remove(index);
+
+
+        delete pTransformer;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_CreateTransformerSaveData(/*in*/ RobustScalarFeaturizer_int64_t_TransformerHandle *pHandle, /*out*/ unsigned char const **ppBuffer, /*out*/ std::size_t *pBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(ppBuffer == nullptr) throw std::invalid_argument("'ppBuffer' is null");
+        if(pBufferSize == nullptr) throw std::invalid_argument("'pBufferSize' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t>::TransformerType & transformer(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t>::TransformerType>(reinterpret_cast<size_t>(pHandle)));
+        Microsoft::Featurizer::Archive archive;
+
+        transformer.save(archive);
+
+        Microsoft::Featurizer::Archive::ByteArray const buffer(archive.commit());
+
+        unsigned char * new_buffer(new unsigned char[buffer.size()]);
+
+        std::copy(buffer.begin(), buffer.end(), new_buffer);
+
+        *ppBuffer = new_buffer;
+        *pBufferSize = buffer.size();
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_DestroyTransformerSaveData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pBuffer == nullptr) throw std::invalid_argument("'pBuffer' is null");
+        if(cBufferSize == 0) throw std::invalid_argument("'cBufferSize' is 0");
+
+        delete [] pBuffer;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_Transform(/*in*/ RobustScalarFeaturizer_int64_t_TransformerHandle *pHandle, /*in*/ int64_t input, /*out*/ double * output, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+
+        // No input validation
+        if(output == nullptr) throw std::invalid_argument("'output' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t>::TransformerType & transformer(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::int64_t>::TransformerType>(reinterpret_cast<size_t>(pHandle)));
+
+        // Input
+        auto result(transformer.execute(input));
+
+        // Output
+        *output = result;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+/* ---------------------------------------------------------------------- */
+/* |                                                                      */
+/* |  RobustScalarFeaturizer <uint32_t> */
+/* |                                                                      */
+/* ---------------------------------------------------------------------- */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_CreateEstimator(/*out*/ RobustScalarFeaturizer_uint32_t_EstimatorHandle **ppHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        // No validation
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t>* pEstimator = new Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t>(std::make_shared<Microsoft::Featurizer::AnnotationMaps>(1));
+        size_t index(g_pointerTable.Add(pEstimator));
+        *ppHandle = reinterpret_cast<RobustScalarFeaturizer_uint32_t_EstimatorHandle*>(index);
+
+
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_DestroyEstimator(/*in*/ RobustScalarFeaturizer_uint32_t_EstimatorHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+        size_t index = reinterpret_cast<size_t>(pHandle);
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t> * pEstimator = g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t>>(index);
+        g_pointerTable.Remove(index);
+
+        delete pEstimator;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_IsTrainingComplete(/*in*/ RobustScalarFeaturizer_uint32_t_EstimatorHandle *pHandle, /*out*/ bool *pIsTrainingComplete, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pIsTrainingComplete == nullptr) throw std::invalid_argument("'pIsTrainingComplete' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t> const & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t>>(reinterpret_cast<size_t>(pHandle)));
+
+
+        *pIsTrainingComplete = estimator.is_training_complete();
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_Fit(/*in*/ RobustScalarFeaturizer_uint32_t_EstimatorHandle *pHandle, /*in*/ uint32_t input, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+        // No validation
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t>>(reinterpret_cast<size_t>(pHandle)));
+
+
+        *pFitResult = static_cast<unsigned char>(estimator.fit(input));
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_FitBuffer(/*in*/ RobustScalarFeaturizer_uint32_t_EstimatorHandle *pHandle, /*in*/ uint32_t const * input_ptr, /*in*/ std::size_t input_items, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+
+        if(input_ptr == nullptr) throw std::invalid_argument("'input_ptr' is null");
+        if(input_items == 0) throw std::invalid_argument("'input_items' is 0");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t>>(reinterpret_cast<size_t>(pHandle)));
+
+        *pFitResult = static_cast<unsigned char>(estimator.fit(input_ptr, input_items));
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_CompleteTraining(/*in*/ RobustScalarFeaturizer_uint32_t_EstimatorHandle *pHandle, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t>>(reinterpret_cast<size_t>(pHandle)));
+
+        *pFitResult = static_cast<unsigned char>(estimator.complete_training());
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_CreateTransformerFromEstimator(/*in*/ RobustScalarFeaturizer_uint32_t_EstimatorHandle *pEstimatorHandle, /*out*/ RobustScalarFeaturizer_uint32_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pEstimatorHandle == nullptr) throw std::invalid_argument("'pEstimatorHandle' is null");
+        if(ppTransformerHandle == nullptr) throw std::invalid_argument("'ppTransformerHandle' is null");
+
+
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t>>(reinterpret_cast<size_t>(pEstimatorHandle)));
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t>::TransformerType * pTransformer = reinterpret_cast<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t>::TransformerType*>(estimator.create_transformer().release());
+
+
+        size_t index = g_pointerTable.Add(pTransformer);
+        *ppTransformerHandle = reinterpret_cast<RobustScalarFeaturizer_uint32_t_TransformerHandle*>(index);
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_CreateTransformerFromSavedData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ RobustScalarFeaturizer_uint32_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pBuffer == nullptr) throw std::invalid_argument("'pBuffer' is null");
+        if(cBufferSize == 0) throw std::invalid_argument("'cBufferSize' is 0");
+        if(ppTransformerHandle == nullptr) throw std::invalid_argument("'ppTransformerHandle' is null");
+
+        Microsoft::Featurizer::Archive archive(pBuffer, cBufferSize);
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t>::TransformerType* pTransformer= (std::make_unique<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t>::TransformerType>(archive).release());
+
+        size_t index = g_pointerTable.Add(pTransformer);
+        *ppTransformerHandle = reinterpret_cast<RobustScalarFeaturizer_uint32_t_TransformerHandle*>(index);
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_DestroyTransformer(/*in*/ RobustScalarFeaturizer_uint32_t_TransformerHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+        size_t index = reinterpret_cast<size_t>(pHandle);
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t>::TransformerType* pTransformer = g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t>::TransformerType>(index);
+        g_pointerTable.Remove(index);
+
+
+        delete pTransformer;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_CreateTransformerSaveData(/*in*/ RobustScalarFeaturizer_uint32_t_TransformerHandle *pHandle, /*out*/ unsigned char const **ppBuffer, /*out*/ std::size_t *pBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(ppBuffer == nullptr) throw std::invalid_argument("'ppBuffer' is null");
+        if(pBufferSize == nullptr) throw std::invalid_argument("'pBufferSize' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t>::TransformerType & transformer(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t>::TransformerType>(reinterpret_cast<size_t>(pHandle)));
+        Microsoft::Featurizer::Archive archive;
+
+        transformer.save(archive);
+
+        Microsoft::Featurizer::Archive::ByteArray const buffer(archive.commit());
+
+        unsigned char * new_buffer(new unsigned char[buffer.size()]);
+
+        std::copy(buffer.begin(), buffer.end(), new_buffer);
+
+        *ppBuffer = new_buffer;
+        *pBufferSize = buffer.size();
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_DestroyTransformerSaveData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pBuffer == nullptr) throw std::invalid_argument("'pBuffer' is null");
+        if(cBufferSize == 0) throw std::invalid_argument("'cBufferSize' is 0");
+
+        delete [] pBuffer;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_Transform(/*in*/ RobustScalarFeaturizer_uint32_t_TransformerHandle *pHandle, /*in*/ uint32_t input, /*out*/ double * output, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+
+        // No input validation
+        if(output == nullptr) throw std::invalid_argument("'output' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t>::TransformerType & transformer(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint32_t>::TransformerType>(reinterpret_cast<size_t>(pHandle)));
+
+        // Input
+        auto result(transformer.execute(input));
+
+        // Output
+        *output = result;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+/* ---------------------------------------------------------------------- */
+/* |                                                                      */
+/* |  RobustScalarFeaturizer <uint64_t> */
+/* |                                                                      */
+/* ---------------------------------------------------------------------- */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_CreateEstimator(/*out*/ RobustScalarFeaturizer_uint64_t_EstimatorHandle **ppHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        // No validation
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t>* pEstimator = new Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t>(std::make_shared<Microsoft::Featurizer::AnnotationMaps>(1));
+        size_t index(g_pointerTable.Add(pEstimator));
+        *ppHandle = reinterpret_cast<RobustScalarFeaturizer_uint64_t_EstimatorHandle*>(index);
+
+
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_DestroyEstimator(/*in*/ RobustScalarFeaturizer_uint64_t_EstimatorHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+        size_t index = reinterpret_cast<size_t>(pHandle);
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t> * pEstimator = g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t>>(index);
+        g_pointerTable.Remove(index);
+
+        delete pEstimator;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_IsTrainingComplete(/*in*/ RobustScalarFeaturizer_uint64_t_EstimatorHandle *pHandle, /*out*/ bool *pIsTrainingComplete, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pIsTrainingComplete == nullptr) throw std::invalid_argument("'pIsTrainingComplete' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t> const & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t>>(reinterpret_cast<size_t>(pHandle)));
+
+
+        *pIsTrainingComplete = estimator.is_training_complete();
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_Fit(/*in*/ RobustScalarFeaturizer_uint64_t_EstimatorHandle *pHandle, /*in*/ uint64_t input, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+        // No validation
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t>>(reinterpret_cast<size_t>(pHandle)));
+
+
+        *pFitResult = static_cast<unsigned char>(estimator.fit(input));
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_FitBuffer(/*in*/ RobustScalarFeaturizer_uint64_t_EstimatorHandle *pHandle, /*in*/ uint64_t const * input_ptr, /*in*/ std::size_t input_items, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+
+        if(input_ptr == nullptr) throw std::invalid_argument("'input_ptr' is null");
+        if(input_items == 0) throw std::invalid_argument("'input_items' is 0");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t>>(reinterpret_cast<size_t>(pHandle)));
+
+        *pFitResult = static_cast<unsigned char>(estimator.fit(input_ptr, input_items));
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_CompleteTraining(/*in*/ RobustScalarFeaturizer_uint64_t_EstimatorHandle *pHandle, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t>>(reinterpret_cast<size_t>(pHandle)));
+
+        *pFitResult = static_cast<unsigned char>(estimator.complete_training());
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_CreateTransformerFromEstimator(/*in*/ RobustScalarFeaturizer_uint64_t_EstimatorHandle *pEstimatorHandle, /*out*/ RobustScalarFeaturizer_uint64_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pEstimatorHandle == nullptr) throw std::invalid_argument("'pEstimatorHandle' is null");
+        if(ppTransformerHandle == nullptr) throw std::invalid_argument("'ppTransformerHandle' is null");
+
+
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t>>(reinterpret_cast<size_t>(pEstimatorHandle)));
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t>::TransformerType * pTransformer = reinterpret_cast<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t>::TransformerType*>(estimator.create_transformer().release());
+
+
+        size_t index = g_pointerTable.Add(pTransformer);
+        *ppTransformerHandle = reinterpret_cast<RobustScalarFeaturizer_uint64_t_TransformerHandle*>(index);
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_CreateTransformerFromSavedData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ RobustScalarFeaturizer_uint64_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pBuffer == nullptr) throw std::invalid_argument("'pBuffer' is null");
+        if(cBufferSize == 0) throw std::invalid_argument("'cBufferSize' is 0");
+        if(ppTransformerHandle == nullptr) throw std::invalid_argument("'ppTransformerHandle' is null");
+
+        Microsoft::Featurizer::Archive archive(pBuffer, cBufferSize);
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t>::TransformerType* pTransformer= (std::make_unique<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t>::TransformerType>(archive).release());
+
+        size_t index = g_pointerTable.Add(pTransformer);
+        *ppTransformerHandle = reinterpret_cast<RobustScalarFeaturizer_uint64_t_TransformerHandle*>(index);
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_DestroyTransformer(/*in*/ RobustScalarFeaturizer_uint64_t_TransformerHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+        size_t index = reinterpret_cast<size_t>(pHandle);
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t>::TransformerType* pTransformer = g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t>::TransformerType>(index);
+        g_pointerTable.Remove(index);
+
+
+        delete pTransformer;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_CreateTransformerSaveData(/*in*/ RobustScalarFeaturizer_uint64_t_TransformerHandle *pHandle, /*out*/ unsigned char const **ppBuffer, /*out*/ std::size_t *pBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(ppBuffer == nullptr) throw std::invalid_argument("'ppBuffer' is null");
+        if(pBufferSize == nullptr) throw std::invalid_argument("'pBufferSize' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t>::TransformerType & transformer(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t>::TransformerType>(reinterpret_cast<size_t>(pHandle)));
+        Microsoft::Featurizer::Archive archive;
+
+        transformer.save(archive);
+
+        Microsoft::Featurizer::Archive::ByteArray const buffer(archive.commit());
+
+        unsigned char * new_buffer(new unsigned char[buffer.size()]);
+
+        std::copy(buffer.begin(), buffer.end(), new_buffer);
+
+        *ppBuffer = new_buffer;
+        *pBufferSize = buffer.size();
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_DestroyTransformerSaveData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pBuffer == nullptr) throw std::invalid_argument("'pBuffer' is null");
+        if(cBufferSize == 0) throw std::invalid_argument("'cBufferSize' is 0");
+
+        delete [] pBuffer;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_Transform(/*in*/ RobustScalarFeaturizer_uint64_t_TransformerHandle *pHandle, /*in*/ uint64_t input, /*out*/ double * output, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+
+        // No input validation
+        if(output == nullptr) throw std::invalid_argument("'output' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t>::TransformerType & transformer(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::uint64_t>::TransformerType>(reinterpret_cast<size_t>(pHandle)));
+
+        // Input
+        auto result(transformer.execute(input));
+
+        // Output
+        *output = result;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+/* ---------------------------------------------------------------------- */
+/* |                                                                      */
+/* |  RobustScalarFeaturizer <double_t> */
+/* |                                                                      */
+/* ---------------------------------------------------------------------- */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_CreateEstimator(/*out*/ RobustScalarFeaturizer_double_t_EstimatorHandle **ppHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        // No validation
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t>* pEstimator = new Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t>(std::make_shared<Microsoft::Featurizer::AnnotationMaps>(1));
+        size_t index(g_pointerTable.Add(pEstimator));
+        *ppHandle = reinterpret_cast<RobustScalarFeaturizer_double_t_EstimatorHandle*>(index);
+
+
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_DestroyEstimator(/*in*/ RobustScalarFeaturizer_double_t_EstimatorHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+        size_t index = reinterpret_cast<size_t>(pHandle);
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t> * pEstimator = g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t>>(index);
+        g_pointerTable.Remove(index);
+
+        delete pEstimator;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_IsTrainingComplete(/*in*/ RobustScalarFeaturizer_double_t_EstimatorHandle *pHandle, /*out*/ bool *pIsTrainingComplete, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pIsTrainingComplete == nullptr) throw std::invalid_argument("'pIsTrainingComplete' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t> const & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t>>(reinterpret_cast<size_t>(pHandle)));
+
+
+        *pIsTrainingComplete = estimator.is_training_complete();
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_Fit(/*in*/ RobustScalarFeaturizer_double_t_EstimatorHandle *pHandle, /*in*/ double input, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+        // No validation
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t>>(reinterpret_cast<size_t>(pHandle)));
+
+
+        *pFitResult = static_cast<unsigned char>(estimator.fit(input));
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_FitBuffer(/*in*/ RobustScalarFeaturizer_double_t_EstimatorHandle *pHandle, /*in*/ double const * input_ptr, /*in*/ std::size_t input_items, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+
+        if(input_ptr == nullptr) throw std::invalid_argument("'input_ptr' is null");
+        if(input_items == 0) throw std::invalid_argument("'input_items' is 0");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t>>(reinterpret_cast<size_t>(pHandle)));
+
+        *pFitResult = static_cast<unsigned char>(estimator.fit(input_ptr, input_items));
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_CompleteTraining(/*in*/ RobustScalarFeaturizer_double_t_EstimatorHandle *pHandle, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(pFitResult == nullptr) throw std::invalid_argument("'pFitResult' is null");
+
+
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t>>(reinterpret_cast<size_t>(pHandle)));
+
+        *pFitResult = static_cast<unsigned char>(estimator.complete_training());
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_CreateTransformerFromEstimator(/*in*/ RobustScalarFeaturizer_double_t_EstimatorHandle *pEstimatorHandle, /*out*/ RobustScalarFeaturizer_double_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pEstimatorHandle == nullptr) throw std::invalid_argument("'pEstimatorHandle' is null");
+        if(ppTransformerHandle == nullptr) throw std::invalid_argument("'ppTransformerHandle' is null");
+
+
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t> & estimator(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t>>(reinterpret_cast<size_t>(pEstimatorHandle)));
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t>::TransformerType * pTransformer = reinterpret_cast<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t>::TransformerType*>(estimator.create_transformer().release());
+
+
+        size_t index = g_pointerTable.Add(pTransformer);
+        *ppTransformerHandle = reinterpret_cast<RobustScalarFeaturizer_double_t_TransformerHandle*>(index);
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_CreateTransformerFromSavedData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ RobustScalarFeaturizer_double_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pBuffer == nullptr) throw std::invalid_argument("'pBuffer' is null");
+        if(cBufferSize == 0) throw std::invalid_argument("'cBufferSize' is 0");
+        if(ppTransformerHandle == nullptr) throw std::invalid_argument("'ppTransformerHandle' is null");
+
+        Microsoft::Featurizer::Archive archive(pBuffer, cBufferSize);
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t>::TransformerType* pTransformer= (std::make_unique<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t>::TransformerType>(archive).release());
+
+        size_t index = g_pointerTable.Add(pTransformer);
+        *ppTransformerHandle = reinterpret_cast<RobustScalarFeaturizer_double_t_TransformerHandle*>(index);
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_DestroyTransformer(/*in*/ RobustScalarFeaturizer_double_t_TransformerHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+        size_t index = reinterpret_cast<size_t>(pHandle);
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t>::TransformerType* pTransformer = g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t>::TransformerType>(index);
+        g_pointerTable.Remove(index);
+
+
+        delete pTransformer;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_CreateTransformerSaveData(/*in*/ RobustScalarFeaturizer_double_t_TransformerHandle *pHandle, /*out*/ unsigned char const **ppBuffer, /*out*/ std::size_t *pBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+        if(ppBuffer == nullptr) throw std::invalid_argument("'ppBuffer' is null");
+        if(pBufferSize == nullptr) throw std::invalid_argument("'pBufferSize' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t>::TransformerType & transformer(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t>::TransformerType>(reinterpret_cast<size_t>(pHandle)));
+        Microsoft::Featurizer::Archive archive;
+
+        transformer.save(archive);
+
+        Microsoft::Featurizer::Archive::ByteArray const buffer(archive.commit());
+
+        unsigned char * new_buffer(new unsigned char[buffer.size()]);
+
+        std::copy(buffer.begin(), buffer.end(), new_buffer);
+
+        *ppBuffer = new_buffer;
+        *pBufferSize = buffer.size();
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_DestroyTransformerSaveData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pBuffer == nullptr) throw std::invalid_argument("'pBuffer' is null");
+        if(cBufferSize == 0) throw std::invalid_argument("'cBufferSize' is 0");
+
+        delete [] pBuffer;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_Transform(/*in*/ RobustScalarFeaturizer_double_t_TransformerHandle *pHandle, /*in*/ double input, /*out*/ double * output, /*out*/ ErrorInfoHandle **ppErrorInfo) {
+    if(ppErrorInfo == nullptr)
+        return false;
+
+    try {
+        *ppErrorInfo = nullptr;
+
+        if(pHandle == nullptr) throw std::invalid_argument("'pHandle' is null");
+
+
+        // No input validation
+        if(output == nullptr) throw std::invalid_argument("'output' is null");
+
+        Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t>::TransformerType & transformer(*g_pointerTable.Get<Microsoft::Featurizer::Featurizers::RobustScalarFeaturizer<std::double_t>::TransformerType>(reinterpret_cast<size_t>(pHandle)));
+
+        // Input
+        auto result(transformer.execute(input));
+
+        // Output
+        *output = result;
+    
+        return true;
+    }
+    catch(std::exception const &ex) {
+        *ppErrorInfo = CreateErrorInfo(ex);
+        return false;
+    }
+}
+
+
+#if (defined _MSC_VER)
+#   pragma warning(pop)
+#endif
+
+} // extern "C"
diff --git a/src/FeaturizerPrep/SharedLibrary/GeneratedCode/SharedLibrary_RobustScalarFeaturizer.h b/src/FeaturizerPrep/SharedLibrary/GeneratedCode/SharedLibrary_RobustScalarFeaturizer.h
new file mode 100644
index 0000000..6662ca4
--- /dev/null
+++ b/src/FeaturizerPrep/SharedLibrary/GeneratedCode/SharedLibrary_RobustScalarFeaturizer.h
@@ -0,0 +1,251 @@
+/* ---------------------------------------------------------------------- */
+/* Copyright (c) Microsoft Corporation. All rights reserved.              */
+/* Licensed under the MIT License                                         */
+/* ---------------------------------------------------------------------- */
+#pragma once
+
+#include "SharedLibrary_Common.h"
+
+extern "C" {
+
+/* ---------------------------------------------------------------------- */
+/* |  RobustScalarFeaturizer <int8_t> */
+struct RobustScalarFeaturizer_int8_t_EstimatorHandle {};
+struct RobustScalarFeaturizer_int8_t_TransformerHandle {};
+
+/* Training Methods */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_CreateEstimator(/*out*/ RobustScalarFeaturizer_int8_t_EstimatorHandle **ppHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_DestroyEstimator(/*in*/ RobustScalarFeaturizer_int8_t_EstimatorHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_IsTrainingComplete(/*in*/ RobustScalarFeaturizer_int8_t_EstimatorHandle *pHandle, /*out*/ bool *pIsTrainingComplete, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_Fit(/*in*/ RobustScalarFeaturizer_int8_t_EstimatorHandle *pHandle, /*in*/ int8_t input, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_FitBuffer(/*in*/ RobustScalarFeaturizer_int8_t_EstimatorHandle *pHandle, /*in*/ int8_t const * input_ptr, /*in*/ std::size_t input_items, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_CompleteTraining(/*in*/ RobustScalarFeaturizer_int8_t_EstimatorHandle *pHandle, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+/* Inference Methods */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_CreateTransformerFromEstimator(/*in*/ RobustScalarFeaturizer_int8_t_EstimatorHandle *pEstimatorHandle, /*out*/ RobustScalarFeaturizer_int8_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_CreateTransformerFromSavedData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ RobustScalarFeaturizer_int8_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_DestroyTransformer(/*in*/ RobustScalarFeaturizer_int8_t_TransformerHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_CreateTransformerSaveData(/*in*/ RobustScalarFeaturizer_int8_t_TransformerHandle *pHandle, /*out*/ unsigned char const **ppBuffer, /*out*/ std::size_t *pBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_DestroyTransformerSaveData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int8_t_Transform(/*in*/ RobustScalarFeaturizer_int8_t_TransformerHandle *pHandle, /*in*/ int8_t input, /*out*/ float * output, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+/* ---------------------------------------------------------------------- */
+/* |  RobustScalarFeaturizer <int16_t> */
+struct RobustScalarFeaturizer_int16_t_EstimatorHandle {};
+struct RobustScalarFeaturizer_int16_t_TransformerHandle {};
+
+/* Training Methods */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_CreateEstimator(/*out*/ RobustScalarFeaturizer_int16_t_EstimatorHandle **ppHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_DestroyEstimator(/*in*/ RobustScalarFeaturizer_int16_t_EstimatorHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_IsTrainingComplete(/*in*/ RobustScalarFeaturizer_int16_t_EstimatorHandle *pHandle, /*out*/ bool *pIsTrainingComplete, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_Fit(/*in*/ RobustScalarFeaturizer_int16_t_EstimatorHandle *pHandle, /*in*/ int16_t input, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_FitBuffer(/*in*/ RobustScalarFeaturizer_int16_t_EstimatorHandle *pHandle, /*in*/ int16_t const * input_ptr, /*in*/ std::size_t input_items, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_CompleteTraining(/*in*/ RobustScalarFeaturizer_int16_t_EstimatorHandle *pHandle, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+/* Inference Methods */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_CreateTransformerFromEstimator(/*in*/ RobustScalarFeaturizer_int16_t_EstimatorHandle *pEstimatorHandle, /*out*/ RobustScalarFeaturizer_int16_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_CreateTransformerFromSavedData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ RobustScalarFeaturizer_int16_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_DestroyTransformer(/*in*/ RobustScalarFeaturizer_int16_t_TransformerHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_CreateTransformerSaveData(/*in*/ RobustScalarFeaturizer_int16_t_TransformerHandle *pHandle, /*out*/ unsigned char const **ppBuffer, /*out*/ std::size_t *pBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_DestroyTransformerSaveData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int16_t_Transform(/*in*/ RobustScalarFeaturizer_int16_t_TransformerHandle *pHandle, /*in*/ int16_t input, /*out*/ float * output, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+/* ---------------------------------------------------------------------- */
+/* |  RobustScalarFeaturizer <uint8_t> */
+struct RobustScalarFeaturizer_uint8_t_EstimatorHandle {};
+struct RobustScalarFeaturizer_uint8_t_TransformerHandle {};
+
+/* Training Methods */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_CreateEstimator(/*out*/ RobustScalarFeaturizer_uint8_t_EstimatorHandle **ppHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_DestroyEstimator(/*in*/ RobustScalarFeaturizer_uint8_t_EstimatorHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_IsTrainingComplete(/*in*/ RobustScalarFeaturizer_uint8_t_EstimatorHandle *pHandle, /*out*/ bool *pIsTrainingComplete, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_Fit(/*in*/ RobustScalarFeaturizer_uint8_t_EstimatorHandle *pHandle, /*in*/ uint8_t input, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_FitBuffer(/*in*/ RobustScalarFeaturizer_uint8_t_EstimatorHandle *pHandle, /*in*/ uint8_t const * input_ptr, /*in*/ std::size_t input_items, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_CompleteTraining(/*in*/ RobustScalarFeaturizer_uint8_t_EstimatorHandle *pHandle, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+/* Inference Methods */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_CreateTransformerFromEstimator(/*in*/ RobustScalarFeaturizer_uint8_t_EstimatorHandle *pEstimatorHandle, /*out*/ RobustScalarFeaturizer_uint8_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_CreateTransformerFromSavedData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ RobustScalarFeaturizer_uint8_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_DestroyTransformer(/*in*/ RobustScalarFeaturizer_uint8_t_TransformerHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_CreateTransformerSaveData(/*in*/ RobustScalarFeaturizer_uint8_t_TransformerHandle *pHandle, /*out*/ unsigned char const **ppBuffer, /*out*/ std::size_t *pBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_DestroyTransformerSaveData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint8_t_Transform(/*in*/ RobustScalarFeaturizer_uint8_t_TransformerHandle *pHandle, /*in*/ uint8_t input, /*out*/ float * output, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+/* ---------------------------------------------------------------------- */
+/* |  RobustScalarFeaturizer <uint16_t> */
+struct RobustScalarFeaturizer_uint16_t_EstimatorHandle {};
+struct RobustScalarFeaturizer_uint16_t_TransformerHandle {};
+
+/* Training Methods */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_CreateEstimator(/*out*/ RobustScalarFeaturizer_uint16_t_EstimatorHandle **ppHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_DestroyEstimator(/*in*/ RobustScalarFeaturizer_uint16_t_EstimatorHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_IsTrainingComplete(/*in*/ RobustScalarFeaturizer_uint16_t_EstimatorHandle *pHandle, /*out*/ bool *pIsTrainingComplete, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_Fit(/*in*/ RobustScalarFeaturizer_uint16_t_EstimatorHandle *pHandle, /*in*/ uint16_t input, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_FitBuffer(/*in*/ RobustScalarFeaturizer_uint16_t_EstimatorHandle *pHandle, /*in*/ uint16_t const * input_ptr, /*in*/ std::size_t input_items, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_CompleteTraining(/*in*/ RobustScalarFeaturizer_uint16_t_EstimatorHandle *pHandle, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+/* Inference Methods */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_CreateTransformerFromEstimator(/*in*/ RobustScalarFeaturizer_uint16_t_EstimatorHandle *pEstimatorHandle, /*out*/ RobustScalarFeaturizer_uint16_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_CreateTransformerFromSavedData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ RobustScalarFeaturizer_uint16_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_DestroyTransformer(/*in*/ RobustScalarFeaturizer_uint16_t_TransformerHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_CreateTransformerSaveData(/*in*/ RobustScalarFeaturizer_uint16_t_TransformerHandle *pHandle, /*out*/ unsigned char const **ppBuffer, /*out*/ std::size_t *pBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_DestroyTransformerSaveData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint16_t_Transform(/*in*/ RobustScalarFeaturizer_uint16_t_TransformerHandle *pHandle, /*in*/ uint16_t input, /*out*/ float * output, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+/* ---------------------------------------------------------------------- */
+/* |  RobustScalarFeaturizer <float_t> */
+struct RobustScalarFeaturizer_float_t_EstimatorHandle {};
+struct RobustScalarFeaturizer_float_t_TransformerHandle {};
+
+/* Training Methods */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_CreateEstimator(/*out*/ RobustScalarFeaturizer_float_t_EstimatorHandle **ppHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_DestroyEstimator(/*in*/ RobustScalarFeaturizer_float_t_EstimatorHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_IsTrainingComplete(/*in*/ RobustScalarFeaturizer_float_t_EstimatorHandle *pHandle, /*out*/ bool *pIsTrainingComplete, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_Fit(/*in*/ RobustScalarFeaturizer_float_t_EstimatorHandle *pHandle, /*in*/ float input, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_FitBuffer(/*in*/ RobustScalarFeaturizer_float_t_EstimatorHandle *pHandle, /*in*/ float const * input_ptr, /*in*/ std::size_t input_items, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_CompleteTraining(/*in*/ RobustScalarFeaturizer_float_t_EstimatorHandle *pHandle, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+/* Inference Methods */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_CreateTransformerFromEstimator(/*in*/ RobustScalarFeaturizer_float_t_EstimatorHandle *pEstimatorHandle, /*out*/ RobustScalarFeaturizer_float_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_CreateTransformerFromSavedData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ RobustScalarFeaturizer_float_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_DestroyTransformer(/*in*/ RobustScalarFeaturizer_float_t_TransformerHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_CreateTransformerSaveData(/*in*/ RobustScalarFeaturizer_float_t_TransformerHandle *pHandle, /*out*/ unsigned char const **ppBuffer, /*out*/ std::size_t *pBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_DestroyTransformerSaveData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_float_t_Transform(/*in*/ RobustScalarFeaturizer_float_t_TransformerHandle *pHandle, /*in*/ float input, /*out*/ float * output, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+/* ---------------------------------------------------------------------- */
+/* |  RobustScalarFeaturizer <int32_t> */
+struct RobustScalarFeaturizer_int32_t_EstimatorHandle {};
+struct RobustScalarFeaturizer_int32_t_TransformerHandle {};
+
+/* Training Methods */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_CreateEstimator(/*out*/ RobustScalarFeaturizer_int32_t_EstimatorHandle **ppHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_DestroyEstimator(/*in*/ RobustScalarFeaturizer_int32_t_EstimatorHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_IsTrainingComplete(/*in*/ RobustScalarFeaturizer_int32_t_EstimatorHandle *pHandle, /*out*/ bool *pIsTrainingComplete, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_Fit(/*in*/ RobustScalarFeaturizer_int32_t_EstimatorHandle *pHandle, /*in*/ int32_t input, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_FitBuffer(/*in*/ RobustScalarFeaturizer_int32_t_EstimatorHandle *pHandle, /*in*/ int32_t const * input_ptr, /*in*/ std::size_t input_items, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_CompleteTraining(/*in*/ RobustScalarFeaturizer_int32_t_EstimatorHandle *pHandle, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+/* Inference Methods */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_CreateTransformerFromEstimator(/*in*/ RobustScalarFeaturizer_int32_t_EstimatorHandle *pEstimatorHandle, /*out*/ RobustScalarFeaturizer_int32_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_CreateTransformerFromSavedData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ RobustScalarFeaturizer_int32_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_DestroyTransformer(/*in*/ RobustScalarFeaturizer_int32_t_TransformerHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_CreateTransformerSaveData(/*in*/ RobustScalarFeaturizer_int32_t_TransformerHandle *pHandle, /*out*/ unsigned char const **ppBuffer, /*out*/ std::size_t *pBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_DestroyTransformerSaveData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int32_t_Transform(/*in*/ RobustScalarFeaturizer_int32_t_TransformerHandle *pHandle, /*in*/ int32_t input, /*out*/ double * output, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+/* ---------------------------------------------------------------------- */
+/* |  RobustScalarFeaturizer <int64_t> */
+struct RobustScalarFeaturizer_int64_t_EstimatorHandle {};
+struct RobustScalarFeaturizer_int64_t_TransformerHandle {};
+
+/* Training Methods */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_CreateEstimator(/*out*/ RobustScalarFeaturizer_int64_t_EstimatorHandle **ppHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_DestroyEstimator(/*in*/ RobustScalarFeaturizer_int64_t_EstimatorHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_IsTrainingComplete(/*in*/ RobustScalarFeaturizer_int64_t_EstimatorHandle *pHandle, /*out*/ bool *pIsTrainingComplete, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_Fit(/*in*/ RobustScalarFeaturizer_int64_t_EstimatorHandle *pHandle, /*in*/ int64_t input, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_FitBuffer(/*in*/ RobustScalarFeaturizer_int64_t_EstimatorHandle *pHandle, /*in*/ int64_t const * input_ptr, /*in*/ std::size_t input_items, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_CompleteTraining(/*in*/ RobustScalarFeaturizer_int64_t_EstimatorHandle *pHandle, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+/* Inference Methods */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_CreateTransformerFromEstimator(/*in*/ RobustScalarFeaturizer_int64_t_EstimatorHandle *pEstimatorHandle, /*out*/ RobustScalarFeaturizer_int64_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_CreateTransformerFromSavedData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ RobustScalarFeaturizer_int64_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_DestroyTransformer(/*in*/ RobustScalarFeaturizer_int64_t_TransformerHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_CreateTransformerSaveData(/*in*/ RobustScalarFeaturizer_int64_t_TransformerHandle *pHandle, /*out*/ unsigned char const **ppBuffer, /*out*/ std::size_t *pBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_DestroyTransformerSaveData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_int64_t_Transform(/*in*/ RobustScalarFeaturizer_int64_t_TransformerHandle *pHandle, /*in*/ int64_t input, /*out*/ double * output, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+/* ---------------------------------------------------------------------- */
+/* |  RobustScalarFeaturizer <uint32_t> */
+struct RobustScalarFeaturizer_uint32_t_EstimatorHandle {};
+struct RobustScalarFeaturizer_uint32_t_TransformerHandle {};
+
+/* Training Methods */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_CreateEstimator(/*out*/ RobustScalarFeaturizer_uint32_t_EstimatorHandle **ppHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_DestroyEstimator(/*in*/ RobustScalarFeaturizer_uint32_t_EstimatorHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_IsTrainingComplete(/*in*/ RobustScalarFeaturizer_uint32_t_EstimatorHandle *pHandle, /*out*/ bool *pIsTrainingComplete, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_Fit(/*in*/ RobustScalarFeaturizer_uint32_t_EstimatorHandle *pHandle, /*in*/ uint32_t input, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_FitBuffer(/*in*/ RobustScalarFeaturizer_uint32_t_EstimatorHandle *pHandle, /*in*/ uint32_t const * input_ptr, /*in*/ std::size_t input_items, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_CompleteTraining(/*in*/ RobustScalarFeaturizer_uint32_t_EstimatorHandle *pHandle, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+/* Inference Methods */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_CreateTransformerFromEstimator(/*in*/ RobustScalarFeaturizer_uint32_t_EstimatorHandle *pEstimatorHandle, /*out*/ RobustScalarFeaturizer_uint32_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_CreateTransformerFromSavedData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ RobustScalarFeaturizer_uint32_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_DestroyTransformer(/*in*/ RobustScalarFeaturizer_uint32_t_TransformerHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_CreateTransformerSaveData(/*in*/ RobustScalarFeaturizer_uint32_t_TransformerHandle *pHandle, /*out*/ unsigned char const **ppBuffer, /*out*/ std::size_t *pBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_DestroyTransformerSaveData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint32_t_Transform(/*in*/ RobustScalarFeaturizer_uint32_t_TransformerHandle *pHandle, /*in*/ uint32_t input, /*out*/ double * output, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+/* ---------------------------------------------------------------------- */
+/* |  RobustScalarFeaturizer <uint64_t> */
+struct RobustScalarFeaturizer_uint64_t_EstimatorHandle {};
+struct RobustScalarFeaturizer_uint64_t_TransformerHandle {};
+
+/* Training Methods */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_CreateEstimator(/*out*/ RobustScalarFeaturizer_uint64_t_EstimatorHandle **ppHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_DestroyEstimator(/*in*/ RobustScalarFeaturizer_uint64_t_EstimatorHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_IsTrainingComplete(/*in*/ RobustScalarFeaturizer_uint64_t_EstimatorHandle *pHandle, /*out*/ bool *pIsTrainingComplete, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_Fit(/*in*/ RobustScalarFeaturizer_uint64_t_EstimatorHandle *pHandle, /*in*/ uint64_t input, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_FitBuffer(/*in*/ RobustScalarFeaturizer_uint64_t_EstimatorHandle *pHandle, /*in*/ uint64_t const * input_ptr, /*in*/ std::size_t input_items, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_CompleteTraining(/*in*/ RobustScalarFeaturizer_uint64_t_EstimatorHandle *pHandle, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+/* Inference Methods */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_CreateTransformerFromEstimator(/*in*/ RobustScalarFeaturizer_uint64_t_EstimatorHandle *pEstimatorHandle, /*out*/ RobustScalarFeaturizer_uint64_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_CreateTransformerFromSavedData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ RobustScalarFeaturizer_uint64_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_DestroyTransformer(/*in*/ RobustScalarFeaturizer_uint64_t_TransformerHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_CreateTransformerSaveData(/*in*/ RobustScalarFeaturizer_uint64_t_TransformerHandle *pHandle, /*out*/ unsigned char const **ppBuffer, /*out*/ std::size_t *pBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_DestroyTransformerSaveData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_uint64_t_Transform(/*in*/ RobustScalarFeaturizer_uint64_t_TransformerHandle *pHandle, /*in*/ uint64_t input, /*out*/ double * output, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+/* ---------------------------------------------------------------------- */
+/* |  RobustScalarFeaturizer <double_t> */
+struct RobustScalarFeaturizer_double_t_EstimatorHandle {};
+struct RobustScalarFeaturizer_double_t_TransformerHandle {};
+
+/* Training Methods */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_CreateEstimator(/*out*/ RobustScalarFeaturizer_double_t_EstimatorHandle **ppHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_DestroyEstimator(/*in*/ RobustScalarFeaturizer_double_t_EstimatorHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_IsTrainingComplete(/*in*/ RobustScalarFeaturizer_double_t_EstimatorHandle *pHandle, /*out*/ bool *pIsTrainingComplete, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_Fit(/*in*/ RobustScalarFeaturizer_double_t_EstimatorHandle *pHandle, /*in*/ double input, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_FitBuffer(/*in*/ RobustScalarFeaturizer_double_t_EstimatorHandle *pHandle, /*in*/ double const * input_ptr, /*in*/ std::size_t input_items, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_CompleteTraining(/*in*/ RobustScalarFeaturizer_double_t_EstimatorHandle *pHandle, /*out*/ FitResult *pFitResult, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+/* Inference Methods */
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_CreateTransformerFromEstimator(/*in*/ RobustScalarFeaturizer_double_t_EstimatorHandle *pEstimatorHandle, /*out*/ RobustScalarFeaturizer_double_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_CreateTransformerFromSavedData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ RobustScalarFeaturizer_double_t_TransformerHandle **ppTransformerHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_DestroyTransformer(/*in*/ RobustScalarFeaturizer_double_t_TransformerHandle *pHandle, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_CreateTransformerSaveData(/*in*/ RobustScalarFeaturizer_double_t_TransformerHandle *pHandle, /*out*/ unsigned char const **ppBuffer, /*out*/ std::size_t *pBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo);
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_DestroyTransformerSaveData(/*in*/ unsigned char const *pBuffer, /*in*/ std::size_t cBufferSize, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+FEATURIZER_LIBRARY_API bool RobustScalarFeaturizer_double_t_Transform(/*in*/ RobustScalarFeaturizer_double_t_TransformerHandle *pHandle, /*in*/ double input, /*out*/ double * output, /*out*/ ErrorInfoHandle **ppErrorInfo);
+
+} // extern "C"
diff --git a/src/FeaturizerPrep/SharedLibrary/IntegrationTests/GeneratedCode/SharedLibraryTests_RobustScalarFeaturizer.h b/src/FeaturizerPrep/SharedLibrary/IntegrationTests/GeneratedCode/SharedLibraryTests_RobustScalarFeaturizer.h
new file mode 100644
index 0000000..07c7687
--- /dev/null
+++ b/src/FeaturizerPrep/SharedLibrary/IntegrationTests/GeneratedCode/SharedLibraryTests_RobustScalarFeaturizer.h
@@ -0,0 +1,1039 @@
+/* ---------------------------------------------------------------------- */
+/* Copyright (c) Microsoft Corporation. All rights reserved.              */
+/* Licensed under the MIT License                                         */
+/* ---------------------------------------------------------------------- */
+#pragma once
+
+#include "SharedLibrary_RobustScalarFeaturizer.h"
+#include "Traits.h"
+
+/* ---------------------------------------------------------------------- */
+/* |  RobustScalarFeaturizer <int8_t> */
+template <typename VectorInputT>
+void RobustScalarFeaturizer_int8_t_Test(
+    std::vector<VectorInputT> const &training_input,
+    std::vector<VectorInputT> const &inference_input,
+    std::function<bool (std::vector<std::float_t> const &)> const &verify_func
+) {
+    ErrorInfoHandle * pErrorInfo(nullptr);
+
+    // Create the estimator
+    RobustScalarFeaturizer_int8_t_EstimatorHandle *pEstimatorHandle(nullptr);
+
+    REQUIRE(RobustScalarFeaturizer_int8_t_CreateEstimator(&pEstimatorHandle, &pErrorInfo));
+    REQUIRE(pEstimatorHandle != nullptr);
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Train
+    if(training_input.empty() == false) {
+        typename std::vector<VectorInputT>::const_iterator iter(training_input.begin());
+
+        while(true) {
+            FitResult result(Continue);
+            auto const & input(*iter);
+
+            REQUIRE(RobustScalarFeaturizer_int8_t_Fit(pEstimatorHandle, input, &result, &pErrorInfo));
+            REQUIRE(pErrorInfo == nullptr);
+
+            if(result == Complete)
+                break;
+
+            if(result == ResetAndContinue) {
+                iter = training_input.begin();
+                continue;
+            }
+
+            if(result == Continue) {
+                ++iter;
+
+                if(iter != training_input.end())
+                    continue;
+
+                REQUIRE(RobustScalarFeaturizer_int8_t_CompleteTraining(pEstimatorHandle, &result, &pErrorInfo));
+                REQUIRE(pErrorInfo == nullptr);
+
+                if(result == Complete)
+                    break;
+
+                if(result == ResetAndContinue) {
+                    iter = training_input.begin();
+                    continue;
+                }
+            }
+
+            INFO("Value is " << result)
+            REQUIRE(false);
+        }
+    }
+
+    // Once here, training should be complete
+    {
+        bool is_complete(false);
+
+        REQUIRE(RobustScalarFeaturizer_int8_t_IsTrainingComplete(pEstimatorHandle, &is_complete, &pErrorInfo));
+        REQUIRE(pErrorInfo == nullptr);
+        REQUIRE(is_complete);
+    }
+
+    // Create the Transformer
+    RobustScalarFeaturizer_int8_t_TransformerHandle * pTransformerHandle(nullptr);
+
+    REQUIRE(RobustScalarFeaturizer_int8_t_CreateTransformerFromEstimator(pEstimatorHandle, &pTransformerHandle, &pErrorInfo));
+    REQUIRE(pTransformerHandle != nullptr);
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Destroy the estimator
+    REQUIRE(RobustScalarFeaturizer_int8_t_DestroyEstimator(pEstimatorHandle, &pErrorInfo));
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Inference
+    std::vector<std::float_t> results;
+
+    results.reserve(inference_input.size());
+
+    for(auto const & input : inference_input) {
+        std::float_t result;
+
+        REQUIRE(RobustScalarFeaturizer_int8_t_Transform(pTransformerHandle, input, &result, &pErrorInfo));
+        REQUIRE(pErrorInfo == nullptr);
+
+        results.emplace_back(std::move(result));
+        // No inline destroy statement
+    }
+
+    REQUIRE(verify_func(results));
+
+    // No trailing destroy statement
+
+    // Destroy the transformer
+    REQUIRE(RobustScalarFeaturizer_int8_t_DestroyTransformer(pTransformerHandle, &pErrorInfo));
+    REQUIRE(pErrorInfo == nullptr);
+}
+
+/* ---------------------------------------------------------------------- */
+/* |  RobustScalarFeaturizer <int16_t> */
+template <typename VectorInputT>
+void RobustScalarFeaturizer_int16_t_Test(
+    std::vector<VectorInputT> const &training_input,
+    std::vector<VectorInputT> const &inference_input,
+    std::function<bool (std::vector<std::float_t> const &)> const &verify_func
+) {
+    ErrorInfoHandle * pErrorInfo(nullptr);
+
+    // Create the estimator
+    RobustScalarFeaturizer_int16_t_EstimatorHandle *pEstimatorHandle(nullptr);
+
+    REQUIRE(RobustScalarFeaturizer_int16_t_CreateEstimator(&pEstimatorHandle, &pErrorInfo));
+    REQUIRE(pEstimatorHandle != nullptr);
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Train
+    if(training_input.empty() == false) {
+        typename std::vector<VectorInputT>::const_iterator iter(training_input.begin());
+
+        while(true) {
+            FitResult result(Continue);
+            auto const & input(*iter);
+
+            REQUIRE(RobustScalarFeaturizer_int16_t_Fit(pEstimatorHandle, input, &result, &pErrorInfo));
+            REQUIRE(pErrorInfo == nullptr);
+
+            if(result == Complete)
+                break;
+
+            if(result == ResetAndContinue) {
+                iter = training_input.begin();
+                continue;
+            }
+
+            if(result == Continue) {
+                ++iter;
+
+                if(iter != training_input.end())
+                    continue;
+
+                REQUIRE(RobustScalarFeaturizer_int16_t_CompleteTraining(pEstimatorHandle, &result, &pErrorInfo));
+                REQUIRE(pErrorInfo == nullptr);
+
+                if(result == Complete)
+                    break;
+
+                if(result == ResetAndContinue) {
+                    iter = training_input.begin();
+                    continue;
+                }
+            }
+
+            INFO("Value is " << result)
+            REQUIRE(false);
+        }
+    }
+
+    // Once here, training should be complete
+    {
+        bool is_complete(false);
+
+        REQUIRE(RobustScalarFeaturizer_int16_t_IsTrainingComplete(pEstimatorHandle, &is_complete, &pErrorInfo));
+        REQUIRE(pErrorInfo == nullptr);
+        REQUIRE(is_complete);
+    }
+
+    // Create the Transformer
+    RobustScalarFeaturizer_int16_t_TransformerHandle * pTransformerHandle(nullptr);
+
+    REQUIRE(RobustScalarFeaturizer_int16_t_CreateTransformerFromEstimator(pEstimatorHandle, &pTransformerHandle, &pErrorInfo));
+    REQUIRE(pTransformerHandle != nullptr);
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Destroy the estimator
+    REQUIRE(RobustScalarFeaturizer_int16_t_DestroyEstimator(pEstimatorHandle, &pErrorInfo));
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Inference
+    std::vector<std::float_t> results;
+
+    results.reserve(inference_input.size());
+
+    for(auto const & input : inference_input) {
+        std::float_t result;
+
+        REQUIRE(RobustScalarFeaturizer_int16_t_Transform(pTransformerHandle, input, &result, &pErrorInfo));
+        REQUIRE(pErrorInfo == nullptr);
+
+        results.emplace_back(std::move(result));
+        // No inline destroy statement
+    }
+
+    REQUIRE(verify_func(results));
+
+    // No trailing destroy statement
+
+    // Destroy the transformer
+    REQUIRE(RobustScalarFeaturizer_int16_t_DestroyTransformer(pTransformerHandle, &pErrorInfo));
+    REQUIRE(pErrorInfo == nullptr);
+}
+
+/* ---------------------------------------------------------------------- */
+/* |  RobustScalarFeaturizer <uint8_t> */
+template <typename VectorInputT>
+void RobustScalarFeaturizer_uint8_t_Test(
+    std::vector<VectorInputT> const &training_input,
+    std::vector<VectorInputT> const &inference_input,
+    std::function<bool (std::vector<std::float_t> const &)> const &verify_func
+) {
+    ErrorInfoHandle * pErrorInfo(nullptr);
+
+    // Create the estimator
+    RobustScalarFeaturizer_uint8_t_EstimatorHandle *pEstimatorHandle(nullptr);
+
+    REQUIRE(RobustScalarFeaturizer_uint8_t_CreateEstimator(&pEstimatorHandle, &pErrorInfo));
+    REQUIRE(pEstimatorHandle != nullptr);
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Train
+    if(training_input.empty() == false) {
+        typename std::vector<VectorInputT>::const_iterator iter(training_input.begin());
+
+        while(true) {
+            FitResult result(Continue);
+            auto const & input(*iter);
+
+            REQUIRE(RobustScalarFeaturizer_uint8_t_Fit(pEstimatorHandle, input, &result, &pErrorInfo));
+            REQUIRE(pErrorInfo == nullptr);
+
+            if(result == Complete)
+                break;
+
+            if(result == ResetAndContinue) {
+                iter = training_input.begin();
+                continue;
+            }
+
+            if(result == Continue) {
+                ++iter;
+
+                if(iter != training_input.end())
+                    continue;
+
+                REQUIRE(RobustScalarFeaturizer_uint8_t_CompleteTraining(pEstimatorHandle, &result, &pErrorInfo));
+                REQUIRE(pErrorInfo == nullptr);
+
+                if(result == Complete)
+                    break;
+
+                if(result == ResetAndContinue) {
+                    iter = training_input.begin();
+                    continue;
+                }
+            }
+
+            INFO("Value is " << result)
+            REQUIRE(false);
+        }
+    }
+
+    // Once here, training should be complete
+    {
+        bool is_complete(false);
+
+        REQUIRE(RobustScalarFeaturizer_uint8_t_IsTrainingComplete(pEstimatorHandle, &is_complete, &pErrorInfo));
+        REQUIRE(pErrorInfo == nullptr);
+        REQUIRE(is_complete);
+    }
+
+    // Create the Transformer
+    RobustScalarFeaturizer_uint8_t_TransformerHandle * pTransformerHandle(nullptr);
+
+    REQUIRE(RobustScalarFeaturizer_uint8_t_CreateTransformerFromEstimator(pEstimatorHandle, &pTransformerHandle, &pErrorInfo));
+    REQUIRE(pTransformerHandle != nullptr);
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Destroy the estimator
+    REQUIRE(RobustScalarFeaturizer_uint8_t_DestroyEstimator(pEstimatorHandle, &pErrorInfo));
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Inference
+    std::vector<std::float_t> results;
+
+    results.reserve(inference_input.size());
+
+    for(auto const & input : inference_input) {
+        std::float_t result;
+
+        REQUIRE(RobustScalarFeaturizer_uint8_t_Transform(pTransformerHandle, input, &result, &pErrorInfo));
+        REQUIRE(pErrorInfo == nullptr);
+
+        results.emplace_back(std::move(result));
+        // No inline destroy statement
+    }
+
+    REQUIRE(verify_func(results));
+
+    // No trailing destroy statement
+
+    // Destroy the transformer
+    REQUIRE(RobustScalarFeaturizer_uint8_t_DestroyTransformer(pTransformerHandle, &pErrorInfo));
+    REQUIRE(pErrorInfo == nullptr);
+}
+
+/* ---------------------------------------------------------------------- */
+/* |  RobustScalarFeaturizer <uint16_t> */
+template <typename VectorInputT>
+void RobustScalarFeaturizer_uint16_t_Test(
+    std::vector<VectorInputT> const &training_input,
+    std::vector<VectorInputT> const &inference_input,
+    std::function<bool (std::vector<std::float_t> const &)> const &verify_func
+) {
+    ErrorInfoHandle * pErrorInfo(nullptr);
+
+    // Create the estimator
+    RobustScalarFeaturizer_uint16_t_EstimatorHandle *pEstimatorHandle(nullptr);
+
+    REQUIRE(RobustScalarFeaturizer_uint16_t_CreateEstimator(&pEstimatorHandle, &pErrorInfo));
+    REQUIRE(pEstimatorHandle != nullptr);
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Train
+    if(training_input.empty() == false) {
+        typename std::vector<VectorInputT>::const_iterator iter(training_input.begin());
+
+        while(true) {
+            FitResult result(Continue);
+            auto const & input(*iter);
+
+            REQUIRE(RobustScalarFeaturizer_uint16_t_Fit(pEstimatorHandle, input, &result, &pErrorInfo));
+            REQUIRE(pErrorInfo == nullptr);
+
+            if(result == Complete)
+                break;
+
+            if(result == ResetAndContinue) {
+                iter = training_input.begin();
+                continue;
+            }
+
+            if(result == Continue) {
+                ++iter;
+
+                if(iter != training_input.end())
+                    continue;
+
+                REQUIRE(RobustScalarFeaturizer_uint16_t_CompleteTraining(pEstimatorHandle, &result, &pErrorInfo));
+                REQUIRE(pErrorInfo == nullptr);
+
+                if(result == Complete)
+                    break;
+
+                if(result == ResetAndContinue) {
+                    iter = training_input.begin();
+                    continue;
+                }
+            }
+
+            INFO("Value is " << result)
+            REQUIRE(false);
+        }
+    }
+
+    // Once here, training should be complete
+    {
+        bool is_complete(false);
+
+        REQUIRE(RobustScalarFeaturizer_uint16_t_IsTrainingComplete(pEstimatorHandle, &is_complete, &pErrorInfo));
+        REQUIRE(pErrorInfo == nullptr);
+        REQUIRE(is_complete);
+    }
+
+    // Create the Transformer
+    RobustScalarFeaturizer_uint16_t_TransformerHandle * pTransformerHandle(nullptr);
+
+    REQUIRE(RobustScalarFeaturizer_uint16_t_CreateTransformerFromEstimator(pEstimatorHandle, &pTransformerHandle, &pErrorInfo));
+    REQUIRE(pTransformerHandle != nullptr);
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Destroy the estimator
+    REQUIRE(RobustScalarFeaturizer_uint16_t_DestroyEstimator(pEstimatorHandle, &pErrorInfo));
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Inference
+    std::vector<std::float_t> results;
+
+    results.reserve(inference_input.size());
+
+    for(auto const & input : inference_input) {
+        std::float_t result;
+
+        REQUIRE(RobustScalarFeaturizer_uint16_t_Transform(pTransformerHandle, input, &result, &pErrorInfo));
+        REQUIRE(pErrorInfo == nullptr);
+
+        results.emplace_back(std::move(result));
+        // No inline destroy statement
+    }
+
+    REQUIRE(verify_func(results));
+
+    // No trailing destroy statement
+
+    // Destroy the transformer
+    REQUIRE(RobustScalarFeaturizer_uint16_t_DestroyTransformer(pTransformerHandle, &pErrorInfo));
+    REQUIRE(pErrorInfo == nullptr);
+}
+
+/* ---------------------------------------------------------------------- */
+/* |  RobustScalarFeaturizer <float_t> */
+template <typename VectorInputT>
+void RobustScalarFeaturizer_float_t_Test(
+    std::vector<VectorInputT> const &training_input,
+    std::vector<VectorInputT> const &inference_input,
+    std::function<bool (std::vector<std::float_t> const &)> const &verify_func
+) {
+    ErrorInfoHandle * pErrorInfo(nullptr);
+
+    // Create the estimator
+    RobustScalarFeaturizer_float_t_EstimatorHandle *pEstimatorHandle(nullptr);
+
+    REQUIRE(RobustScalarFeaturizer_float_t_CreateEstimator(&pEstimatorHandle, &pErrorInfo));
+    REQUIRE(pEstimatorHandle != nullptr);
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Train
+    if(training_input.empty() == false) {
+        typename std::vector<VectorInputT>::const_iterator iter(training_input.begin());
+
+        while(true) {
+            FitResult result(Continue);
+            auto const & input(*iter);
+
+            REQUIRE(RobustScalarFeaturizer_float_t_Fit(pEstimatorHandle, input, &result, &pErrorInfo));
+            REQUIRE(pErrorInfo == nullptr);
+
+            if(result == Complete)
+                break;
+
+            if(result == ResetAndContinue) {
+                iter = training_input.begin();
+                continue;
+            }
+
+            if(result == Continue) {
+                ++iter;
+
+                if(iter != training_input.end())
+                    continue;
+
+                REQUIRE(RobustScalarFeaturizer_float_t_CompleteTraining(pEstimatorHandle, &result, &pErrorInfo));
+                REQUIRE(pErrorInfo == nullptr);
+
+                if(result == Complete)
+                    break;
+
+                if(result == ResetAndContinue) {
+                    iter = training_input.begin();
+                    continue;
+                }
+            }
+
+            INFO("Value is " << result)
+            REQUIRE(false);
+        }
+    }
+
+    // Once here, training should be complete
+    {
+        bool is_complete(false);
+
+        REQUIRE(RobustScalarFeaturizer_float_t_IsTrainingComplete(pEstimatorHandle, &is_complete, &pErrorInfo));
+        REQUIRE(pErrorInfo == nullptr);
+        REQUIRE(is_complete);
+    }
+
+    // Create the Transformer
+    RobustScalarFeaturizer_float_t_TransformerHandle * pTransformerHandle(nullptr);
+
+    REQUIRE(RobustScalarFeaturizer_float_t_CreateTransformerFromEstimator(pEstimatorHandle, &pTransformerHandle, &pErrorInfo));
+    REQUIRE(pTransformerHandle != nullptr);
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Destroy the estimator
+    REQUIRE(RobustScalarFeaturizer_float_t_DestroyEstimator(pEstimatorHandle, &pErrorInfo));
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Inference
+    std::vector<std::float_t> results;
+
+    results.reserve(inference_input.size());
+
+    for(auto const & input : inference_input) {
+        std::float_t result;
+
+        REQUIRE(RobustScalarFeaturizer_float_t_Transform(pTransformerHandle, input, &result, &pErrorInfo));
+        REQUIRE(pErrorInfo == nullptr);
+
+        results.emplace_back(std::move(result));
+        // No inline destroy statement
+    }
+
+    REQUIRE(verify_func(results));
+
+    // No trailing destroy statement
+
+    // Destroy the transformer
+    REQUIRE(RobustScalarFeaturizer_float_t_DestroyTransformer(pTransformerHandle, &pErrorInfo));
+    REQUIRE(pErrorInfo == nullptr);
+}
+
+/* ---------------------------------------------------------------------- */
+/* |  RobustScalarFeaturizer <int32_t> */
+template <typename VectorInputT>
+void RobustScalarFeaturizer_int32_t_Test(
+    std::vector<VectorInputT> const &training_input,
+    std::vector<VectorInputT> const &inference_input,
+    std::function<bool (std::vector<std::double_t> const &)> const &verify_func
+) {
+    ErrorInfoHandle * pErrorInfo(nullptr);
+
+    // Create the estimator
+    RobustScalarFeaturizer_int32_t_EstimatorHandle *pEstimatorHandle(nullptr);
+
+    REQUIRE(RobustScalarFeaturizer_int32_t_CreateEstimator(&pEstimatorHandle, &pErrorInfo));
+    REQUIRE(pEstimatorHandle != nullptr);
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Train
+    if(training_input.empty() == false) {
+        typename std::vector<VectorInputT>::const_iterator iter(training_input.begin());
+
+        while(true) {
+            FitResult result(Continue);
+            auto const & input(*iter);
+
+            REQUIRE(RobustScalarFeaturizer_int32_t_Fit(pEstimatorHandle, input, &result, &pErrorInfo));
+            REQUIRE(pErrorInfo == nullptr);
+
+            if(result == Complete)
+                break;
+
+            if(result == ResetAndContinue) {
+                iter = training_input.begin();
+                continue;
+            }
+
+            if(result == Continue) {
+                ++iter;
+
+                if(iter != training_input.end())
+                    continue;
+
+                REQUIRE(RobustScalarFeaturizer_int32_t_CompleteTraining(pEstimatorHandle, &result, &pErrorInfo));
+                REQUIRE(pErrorInfo == nullptr);
+
+                if(result == Complete)
+                    break;
+
+                if(result == ResetAndContinue) {
+                    iter = training_input.begin();
+                    continue;
+                }
+            }
+
+            INFO("Value is " << result)
+            REQUIRE(false);
+        }
+    }
+
+    // Once here, training should be complete
+    {
+        bool is_complete(false);
+
+        REQUIRE(RobustScalarFeaturizer_int32_t_IsTrainingComplete(pEstimatorHandle, &is_complete, &pErrorInfo));
+        REQUIRE(pErrorInfo == nullptr);
+        REQUIRE(is_complete);
+    }
+
+    // Create the Transformer
+    RobustScalarFeaturizer_int32_t_TransformerHandle * pTransformerHandle(nullptr);
+
+    REQUIRE(RobustScalarFeaturizer_int32_t_CreateTransformerFromEstimator(pEstimatorHandle, &pTransformerHandle, &pErrorInfo));
+    REQUIRE(pTransformerHandle != nullptr);
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Destroy the estimator
+    REQUIRE(RobustScalarFeaturizer_int32_t_DestroyEstimator(pEstimatorHandle, &pErrorInfo));
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Inference
+    std::vector<std::double_t> results;
+
+    results.reserve(inference_input.size());
+
+    for(auto const & input : inference_input) {
+        std::double_t result;
+
+        REQUIRE(RobustScalarFeaturizer_int32_t_Transform(pTransformerHandle, input, &result, &pErrorInfo));
+        REQUIRE(pErrorInfo == nullptr);
+
+        results.emplace_back(std::move(result));
+        // No inline destroy statement
+    }
+
+    REQUIRE(verify_func(results));
+
+    // No trailing destroy statement
+
+    // Destroy the transformer
+    REQUIRE(RobustScalarFeaturizer_int32_t_DestroyTransformer(pTransformerHandle, &pErrorInfo));
+    REQUIRE(pErrorInfo == nullptr);
+}
+
+/* ---------------------------------------------------------------------- */
+/* |  RobustScalarFeaturizer <int64_t> */
+template <typename VectorInputT>
+void RobustScalarFeaturizer_int64_t_Test(
+    std::vector<VectorInputT> const &training_input,
+    std::vector<VectorInputT> const &inference_input,
+    std::function<bool (std::vector<std::double_t> const &)> const &verify_func
+) {
+    ErrorInfoHandle * pErrorInfo(nullptr);
+
+    // Create the estimator
+    RobustScalarFeaturizer_int64_t_EstimatorHandle *pEstimatorHandle(nullptr);
+
+    REQUIRE(RobustScalarFeaturizer_int64_t_CreateEstimator(&pEstimatorHandle, &pErrorInfo));
+    REQUIRE(pEstimatorHandle != nullptr);
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Train
+    if(training_input.empty() == false) {
+        typename std::vector<VectorInputT>::const_iterator iter(training_input.begin());
+
+        while(true) {
+            FitResult result(Continue);
+            auto const & input(*iter);
+
+            REQUIRE(RobustScalarFeaturizer_int64_t_Fit(pEstimatorHandle, input, &result, &pErrorInfo));
+            REQUIRE(pErrorInfo == nullptr);
+
+            if(result == Complete)
+                break;
+
+            if(result == ResetAndContinue) {
+                iter = training_input.begin();
+                continue;
+            }
+
+            if(result == Continue) {
+                ++iter;
+
+                if(iter != training_input.end())
+                    continue;
+
+                REQUIRE(RobustScalarFeaturizer_int64_t_CompleteTraining(pEstimatorHandle, &result, &pErrorInfo));
+                REQUIRE(pErrorInfo == nullptr);
+
+                if(result == Complete)
+                    break;
+
+                if(result == ResetAndContinue) {
+                    iter = training_input.begin();
+                    continue;
+                }
+            }
+
+            INFO("Value is " << result)
+            REQUIRE(false);
+        }
+    }
+
+    // Once here, training should be complete
+    {
+        bool is_complete(false);
+
+        REQUIRE(RobustScalarFeaturizer_int64_t_IsTrainingComplete(pEstimatorHandle, &is_complete, &pErrorInfo));
+        REQUIRE(pErrorInfo == nullptr);
+        REQUIRE(is_complete);
+    }
+
+    // Create the Transformer
+    RobustScalarFeaturizer_int64_t_TransformerHandle * pTransformerHandle(nullptr);
+
+    REQUIRE(RobustScalarFeaturizer_int64_t_CreateTransformerFromEstimator(pEstimatorHandle, &pTransformerHandle, &pErrorInfo));
+    REQUIRE(pTransformerHandle != nullptr);
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Destroy the estimator
+    REQUIRE(RobustScalarFeaturizer_int64_t_DestroyEstimator(pEstimatorHandle, &pErrorInfo));
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Inference
+    std::vector<std::double_t> results;
+
+    results.reserve(inference_input.size());
+
+    for(auto const & input : inference_input) {
+        std::double_t result;
+
+        REQUIRE(RobustScalarFeaturizer_int64_t_Transform(pTransformerHandle, input, &result, &pErrorInfo));
+        REQUIRE(pErrorInfo == nullptr);
+
+        results.emplace_back(std::move(result));
+        // No inline destroy statement
+    }
+
+    REQUIRE(verify_func(results));
+
+    // No trailing destroy statement
+
+    // Destroy the transformer
+    REQUIRE(RobustScalarFeaturizer_int64_t_DestroyTransformer(pTransformerHandle, &pErrorInfo));
+    REQUIRE(pErrorInfo == nullptr);
+}
+
+/* ---------------------------------------------------------------------- */
+/* |  RobustScalarFeaturizer <uint32_t> */
+template <typename VectorInputT>
+void RobustScalarFeaturizer_uint32_t_Test(
+    std::vector<VectorInputT> const &training_input,
+    std::vector<VectorInputT> const &inference_input,
+    std::function<bool (std::vector<std::double_t> const &)> const &verify_func
+) {
+    ErrorInfoHandle * pErrorInfo(nullptr);
+
+    // Create the estimator
+    RobustScalarFeaturizer_uint32_t_EstimatorHandle *pEstimatorHandle(nullptr);
+
+    REQUIRE(RobustScalarFeaturizer_uint32_t_CreateEstimator(&pEstimatorHandle, &pErrorInfo));
+    REQUIRE(pEstimatorHandle != nullptr);
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Train
+    if(training_input.empty() == false) {
+        typename std::vector<VectorInputT>::const_iterator iter(training_input.begin());
+
+        while(true) {
+            FitResult result(Continue);
+            auto const & input(*iter);
+
+            REQUIRE(RobustScalarFeaturizer_uint32_t_Fit(pEstimatorHandle, input, &result, &pErrorInfo));
+            REQUIRE(pErrorInfo == nullptr);
+
+            if(result == Complete)
+                break;
+
+            if(result == ResetAndContinue) {
+                iter = training_input.begin();
+                continue;
+            }
+
+            if(result == Continue) {
+                ++iter;
+
+                if(iter != training_input.end())
+                    continue;
+
+                REQUIRE(RobustScalarFeaturizer_uint32_t_CompleteTraining(pEstimatorHandle, &result, &pErrorInfo));
+                REQUIRE(pErrorInfo == nullptr);
+
+                if(result == Complete)
+                    break;
+
+                if(result == ResetAndContinue) {
+                    iter = training_input.begin();
+                    continue;
+                }
+            }
+
+            INFO("Value is " << result)
+            REQUIRE(false);
+        }
+    }
+
+    // Once here, training should be complete
+    {
+        bool is_complete(false);
+
+        REQUIRE(RobustScalarFeaturizer_uint32_t_IsTrainingComplete(pEstimatorHandle, &is_complete, &pErrorInfo));
+        REQUIRE(pErrorInfo == nullptr);
+        REQUIRE(is_complete);
+    }
+
+    // Create the Transformer
+    RobustScalarFeaturizer_uint32_t_TransformerHandle * pTransformerHandle(nullptr);
+
+    REQUIRE(RobustScalarFeaturizer_uint32_t_CreateTransformerFromEstimator(pEstimatorHandle, &pTransformerHandle, &pErrorInfo));
+    REQUIRE(pTransformerHandle != nullptr);
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Destroy the estimator
+    REQUIRE(RobustScalarFeaturizer_uint32_t_DestroyEstimator(pEstimatorHandle, &pErrorInfo));
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Inference
+    std::vector<std::double_t> results;
+
+    results.reserve(inference_input.size());
+
+    for(auto const & input : inference_input) {
+        std::double_t result;
+
+        REQUIRE(RobustScalarFeaturizer_uint32_t_Transform(pTransformerHandle, input, &result, &pErrorInfo));
+        REQUIRE(pErrorInfo == nullptr);
+
+        results.emplace_back(std::move(result));
+        // No inline destroy statement
+    }
+
+    REQUIRE(verify_func(results));
+
+    // No trailing destroy statement
+
+    // Destroy the transformer
+    REQUIRE(RobustScalarFeaturizer_uint32_t_DestroyTransformer(pTransformerHandle, &pErrorInfo));
+    REQUIRE(pErrorInfo == nullptr);
+}
+
+/* ---------------------------------------------------------------------- */
+/* |  RobustScalarFeaturizer <uint64_t> */
+template <typename VectorInputT>
+void RobustScalarFeaturizer_uint64_t_Test(
+    std::vector<VectorInputT> const &training_input,
+    std::vector<VectorInputT> const &inference_input,
+    std::function<bool (std::vector<std::double_t> const &)> const &verify_func
+) {
+    ErrorInfoHandle * pErrorInfo(nullptr);
+
+    // Create the estimator
+    RobustScalarFeaturizer_uint64_t_EstimatorHandle *pEstimatorHandle(nullptr);
+
+    REQUIRE(RobustScalarFeaturizer_uint64_t_CreateEstimator(&pEstimatorHandle, &pErrorInfo));
+    REQUIRE(pEstimatorHandle != nullptr);
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Train
+    if(training_input.empty() == false) {
+        typename std::vector<VectorInputT>::const_iterator iter(training_input.begin());
+
+        while(true) {
+            FitResult result(Continue);
+            auto const & input(*iter);
+
+            REQUIRE(RobustScalarFeaturizer_uint64_t_Fit(pEstimatorHandle, input, &result, &pErrorInfo));
+            REQUIRE(pErrorInfo == nullptr);
+
+            if(result == Complete)
+                break;
+
+            if(result == ResetAndContinue) {
+                iter = training_input.begin();
+                continue;
+            }
+
+            if(result == Continue) {
+                ++iter;
+
+                if(iter != training_input.end())
+                    continue;
+
+                REQUIRE(RobustScalarFeaturizer_uint64_t_CompleteTraining(pEstimatorHandle, &result, &pErrorInfo));
+                REQUIRE(pErrorInfo == nullptr);
+
+                if(result == Complete)
+                    break;
+
+                if(result == ResetAndContinue) {
+                    iter = training_input.begin();
+                    continue;
+                }
+            }
+
+            INFO("Value is " << result)
+            REQUIRE(false);
+        }
+    }
+
+    // Once here, training should be complete
+    {
+        bool is_complete(false);
+
+        REQUIRE(RobustScalarFeaturizer_uint64_t_IsTrainingComplete(pEstimatorHandle, &is_complete, &pErrorInfo));
+        REQUIRE(pErrorInfo == nullptr);
+        REQUIRE(is_complete);
+    }
+
+    // Create the Transformer
+    RobustScalarFeaturizer_uint64_t_TransformerHandle * pTransformerHandle(nullptr);
+
+    REQUIRE(RobustScalarFeaturizer_uint64_t_CreateTransformerFromEstimator(pEstimatorHandle, &pTransformerHandle, &pErrorInfo));
+    REQUIRE(pTransformerHandle != nullptr);
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Destroy the estimator
+    REQUIRE(RobustScalarFeaturizer_uint64_t_DestroyEstimator(pEstimatorHandle, &pErrorInfo));
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Inference
+    std::vector<std::double_t> results;
+
+    results.reserve(inference_input.size());
+
+    for(auto const & input : inference_input) {
+        std::double_t result;
+
+        REQUIRE(RobustScalarFeaturizer_uint64_t_Transform(pTransformerHandle, input, &result, &pErrorInfo));
+        REQUIRE(pErrorInfo == nullptr);
+
+        results.emplace_back(std::move(result));
+        // No inline destroy statement
+    }
+
+    REQUIRE(verify_func(results));
+
+    // No trailing destroy statement
+
+    // Destroy the transformer
+    REQUIRE(RobustScalarFeaturizer_uint64_t_DestroyTransformer(pTransformerHandle, &pErrorInfo));
+    REQUIRE(pErrorInfo == nullptr);
+}
+
+/* ---------------------------------------------------------------------- */
+/* |  RobustScalarFeaturizer <double_t> */
+template <typename VectorInputT>
+void RobustScalarFeaturizer_double_t_Test(
+    std::vector<VectorInputT> const &training_input,
+    std::vector<VectorInputT> const &inference_input,
+    std::function<bool (std::vector<std::double_t> const &)> const &verify_func
+) {
+    ErrorInfoHandle * pErrorInfo(nullptr);
+
+    // Create the estimator
+    RobustScalarFeaturizer_double_t_EstimatorHandle *pEstimatorHandle(nullptr);
+
+    REQUIRE(RobustScalarFeaturizer_double_t_CreateEstimator(&pEstimatorHandle, &pErrorInfo));
+    REQUIRE(pEstimatorHandle != nullptr);
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Train
+    if(training_input.empty() == false) {
+        typename std::vector<VectorInputT>::const_iterator iter(training_input.begin());
+
+        while(true) {
+            FitResult result(Continue);
+            auto const & input(*iter);
+
+            REQUIRE(RobustScalarFeaturizer_double_t_Fit(pEstimatorHandle, input, &result, &pErrorInfo));
+            REQUIRE(pErrorInfo == nullptr);
+
+            if(result == Complete)
+                break;
+
+            if(result == ResetAndContinue) {
+                iter = training_input.begin();
+                continue;
+            }
+
+            if(result == Continue) {
+                ++iter;
+
+                if(iter != training_input.end())
+                    continue;
+
+                REQUIRE(RobustScalarFeaturizer_double_t_CompleteTraining(pEstimatorHandle, &result, &pErrorInfo));
+                REQUIRE(pErrorInfo == nullptr);
+
+                if(result == Complete)
+                    break;
+
+                if(result == ResetAndContinue) {
+                    iter = training_input.begin();
+                    continue;
+                }
+            }
+
+            INFO("Value is " << result)
+            REQUIRE(false);
+        }
+    }
+
+    // Once here, training should be complete
+    {
+        bool is_complete(false);
+
+        REQUIRE(RobustScalarFeaturizer_double_t_IsTrainingComplete(pEstimatorHandle, &is_complete, &pErrorInfo));
+        REQUIRE(pErrorInfo == nullptr);
+        REQUIRE(is_complete);
+    }
+
+    // Create the Transformer
+    RobustScalarFeaturizer_double_t_TransformerHandle * pTransformerHandle(nullptr);
+
+    REQUIRE(RobustScalarFeaturizer_double_t_CreateTransformerFromEstimator(pEstimatorHandle, &pTransformerHandle, &pErrorInfo));
+    REQUIRE(pTransformerHandle != nullptr);
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Destroy the estimator
+    REQUIRE(RobustScalarFeaturizer_double_t_DestroyEstimator(pEstimatorHandle, &pErrorInfo));
+    REQUIRE(pErrorInfo == nullptr);
+
+    // Inference
+    std::vector<std::double_t> results;
+
+    results.reserve(inference_input.size());
+
+    for(auto const & input : inference_input) {
+        std::double_t result;
+
+        REQUIRE(RobustScalarFeaturizer_double_t_Transform(pTransformerHandle, input, &result, &pErrorInfo));
+        REQUIRE(pErrorInfo == nullptr);
+
+        results.emplace_back(std::move(result));
+        // No inline destroy statement
+    }
+
+    REQUIRE(verify_func(results));
+
+    // No trailing destroy statement
+
+    // Destroy the transformer
+    REQUIRE(RobustScalarFeaturizer_double_t_DestroyTransformer(pTransformerHandle, &pErrorInfo));
+    REQUIRE(pErrorInfo == nullptr);
+}
+
diff --git a/src/FeaturizerPrep/Tools/CodeGenerator/Featurizers.SimpleSchema b/src/FeaturizerPrep/Tools/CodeGenerator/Featurizers.SimpleSchema
index 8d6edc0..51040bf 100644
--- a/src/FeaturizerPrep/Tools/CodeGenerator/Featurizers.SimpleSchema
+++ b/src/FeaturizerPrep/Tools/CodeGenerator/Featurizers.SimpleSchema
@@ -14,12 +14,13 @@
         <name string>
         <is_optional bool default="false" ?>
 
-    <template ?>:
+    <templates *>:
         [name string]
         <types string +>
 
-    <input_type string>
-    <is_input_optional bool default=false ?>
-
-    <transformed_type string>
-    <is_output_optional bool default=false ?>
+    <transformed_type_mappings +>:
+        <input_type string>
+        <is_input_optional bool default=false ?>
+        
+        <transformed_type string>
+        <is_output_optional bool default=false ?>    
diff --git a/src/FeaturizerPrep/Tools/CodeGenerator/Featurizers.json b/src/FeaturizerPrep/Tools/CodeGenerator/Featurizers.json
index b20d50e..c523002 100644
--- a/src/FeaturizerPrep/Tools/CodeGenerator/Featurizers.json
+++ b/src/FeaturizerPrep/Tools/CodeGenerator/Featurizers.json
@@ -3,33 +3,43 @@
         "name": "CatImputerFeaturizer",
         "estimator_name": "CatImputerEstimator",
         "num_output_columns": 1,
-        "template": {
-            "name": "T",
-            "types": [
-                "std::int8_t",
-                "std::int16_t",
-                "std::int32_t",
-                "std::int64_t",
-                "std::uint8_t",
-                "std::uint16_t",
-                "std::uint32_t",
-                "std::uint64_t",
-                "std::float_t",
-                "std::double_t",
-                "bool",
-                "std::string"
-            ]
-        },
-        "input_type": "T",
-        "is_input_optional": true,
-        "transformed_type": "T"
+        "templates": [
+            {
+                "name": "T",
+                "types": [
+                    "std::int8_t",
+                    "std::int16_t",
+                    "std::int32_t",
+                    "std::int64_t",
+                    "std::uint8_t",
+                    "std::uint16_t",
+                    "std::uint32_t",
+                    "std::uint64_t",
+                    "std::float_t",
+                    "std::double_t",
+                    "bool",
+                    "std::string"
+                ]
+            }
+        ],
+        "transformed_type_mappings": [
+            {
+                "input_type": "T",
+                "is_input_optional": true,
+                "transformed_type": "T"
+            }
+        ]
     },
     {
         "name": "DateTimeFeaturizer",
         "estimator_name": "DateTimeEstimator",
         "num_output_columns": 21,
-        "input_type": "std::int64_t",
-        "transformed_type": "TimePoint",
+        "transformed_type_mappings": [
+            {
+                "input_type": "std::int64_t",
+                "transformed_type": "TimePoint"
+            }
+        ],
         "configuration_params": [
             {
                 "type": "std::string",
@@ -138,24 +148,67 @@
         "name": "StringFeaturizer",
         "estimator_name": "StringEstimator",
         "num_output_columns": 1,
-        "template": {
-            "name": "T",
-            "types": [
-                "std::int8_t",
-                "std::int16_t",
-                "std::int32_t",
-                "std::int64_t",
-                "std::uint8_t",
-                "std::uint16_t",
-                "std::uint32_t",
-                "std::uint64_t",
-                "std::float_t",
-                "std::double_t",
-                "bool",
-                "std::string"
-            ]
-        },
-        "input_type": "T",
-        "transformed_type": "std::string"
+        "templates": [
+            {
+                "name": "T",
+                "types": [
+                    "std::int8_t",
+                    "std::int16_t",
+                    "std::int32_t",
+                    "std::int64_t",
+                    "std::uint8_t",
+                    "std::uint16_t",
+                    "std::uint32_t",
+                    "std::uint64_t",
+                    "std::float_t",
+                    "std::double_t",
+                    "bool",
+                    "std::string"
+                ]
+            }
+        ],
+        "transformed_type_mappings": [
+            {
+                "input_type": "T",
+                "transformed_type": "std::string"
+            }
+        ]
+    },
+    {
+        "name": "RobustScalarFeaturizer",
+        "estimator_name": "RobustScalarFeaturizer",
+        "num_output_columns": 1,
+        "templates": [
+            {
+                "name": "TInputFloat",
+                "types": [
+                    "std::int8_t",
+                    "std::int16_t",
+                    "std::uint8_t",
+                    "std::uint16_t",
+                    "std::float_t"
+                ]
+            },
+            {
+                "name": "TInputDouble",
+                "types": [
+                    "std::int32_t",
+                    "std::int64_t",
+                    "std::uint32_t",
+                    "std::uint64_t",
+                    "std::double_t"
+                ]
+            }
+        ],
+        "transformed_type_mappings": [
+            {
+                "input_type": "TInputFloat",
+                "transformed_type": "std::float_t"
+            },
+            {
+                "input_type": "TInputDouble",
+                "transformed_type": "std::double_t"
+            }
+        ]
     }
 ]
diff --git a/src/FeaturizerPrep/Tools/CodeGenerator/GeneratedCode/Compiler.ConditionalInvocationQueryMixin.data b/src/FeaturizerPrep/Tools/CodeGenerator/GeneratedCode/Compiler.ConditionalInvocationQueryMixin.data
index f49d951..ae4a35d 100644
--- a/src/FeaturizerPrep/Tools/CodeGenerator/GeneratedCode/Compiler.ConditionalInvocationQueryMixin.data
+++ b/src/FeaturizerPrep/Tools/CodeGenerator/GeneratedCode/Compiler.ConditionalInvocationQueryMixin.data
@@ -2,4 +2,4 @@
 - compilation invocations.
 -
 - ***** Please do not modify this file *****
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
diff --git a/src/FeaturizerPrep/Tools/CodeGenerator/GeneratedCode/Featurizers_PythonJsonSerialization.py b/src/FeaturizerPrep/Tools/CodeGenerator/GeneratedCode/Featurizers_PythonJsonSerialization.py
index 5358a58..cda6fef 100644
--- a/src/FeaturizerPrep/Tools/CodeGenerator/GeneratedCode/Featurizers_PythonJsonSerialization.py
+++ b/src/FeaturizerPrep/Tools/CodeGenerator/GeneratedCode/Featurizers_PythonJsonSerialization.py
@@ -5,7 +5,7 @@
 # |  future invocations of the generator!
 # |
 # |  Generated by: <SimpleSchemaGenerator>/Plugins/Impl/PythonSerializationImpl.py
-# |  Generated on: 2019-08-27 09:07:48.630260
+# |  Generated on: 2019-10-03 14:10:56.707988
 # |
 # --------------------------------------------------------------------------------
 import copy
@@ -148,13 +148,14 @@ def Deserialize_featurizers(
 # |  Type Infos
 # |
 # ----------------------------------------------------------------------
-featurizers_TypeInfo                                                        = ClassTypeInfo(OrderedDict([ ( "name", StringTypeInfo(min_length=1) ), ( "estimator_name", StringTypeInfo(min_length=1) ), ( "num_output_columns", FloatTypeInfo(min=1.0) ), ( "custom_structs", ClassTypeInfo(OrderedDict([ ( "name", StringTypeInfo(min_length=1) ), ( "members", ClassTypeInfo(OrderedDict([ ( "type", StringTypeInfo(min_length=1) ), ( "name", StringTypeInfo(min_length=1) ) ]), require_exact_match=True, arity=Arity.FromString('+')) ) ]), require_exact_match=True, arity=Arity.FromString('*')) ), ( "configuration_params", ClassTypeInfo(OrderedDict([ ( "type", StringTypeInfo(min_length=1) ), ( "name", StringTypeInfo(min_length=1) ), ( "is_optional", BoolTypeInfo(arity=Arity.FromString('?')) ) ]), require_exact_match=True, arity=Arity.FromString('*')) ), ( "template", ClassTypeInfo(OrderedDict([ ( "name", StringTypeInfo(min_length=1) ), ( "types", StringTypeInfo(min_length=1, arity=Arity.FromString('+')) ) ]), require_exact_match=True, arity=Arity.FromString('?')) ), ( "input_type", StringTypeInfo(min_length=1) ), ( "is_input_optional", BoolTypeInfo(arity=Arity.FromString('?')) ), ( "transformed_type", StringTypeInfo(min_length=1) ), ( "is_output_optional", BoolTypeInfo(arity=Arity.FromString('?')) ) ]), require_exact_match=True, arity=Arity.FromString('+'))
+featurizers_TypeInfo                                                        = ClassTypeInfo(OrderedDict([ ( "name", StringTypeInfo(min_length=1) ), ( "estimator_name", StringTypeInfo(min_length=1) ), ( "num_output_columns", FloatTypeInfo(min=1.0) ), ( "custom_structs", ClassTypeInfo(OrderedDict([ ( "name", StringTypeInfo(min_length=1) ), ( "members", ClassTypeInfo(OrderedDict([ ( "type", StringTypeInfo(min_length=1) ), ( "name", StringTypeInfo(min_length=1) ) ]), require_exact_match=True, arity=Arity.FromString('+')) ) ]), require_exact_match=True, arity=Arity.FromString('*')) ), ( "configuration_params", ClassTypeInfo(OrderedDict([ ( "type", StringTypeInfo(min_length=1) ), ( "name", StringTypeInfo(min_length=1) ), ( "is_optional", BoolTypeInfo(arity=Arity.FromString('?')) ) ]), require_exact_match=True, arity=Arity.FromString('*')) ), ( "templates", ClassTypeInfo(OrderedDict([ ( "name", StringTypeInfo(min_length=1) ), ( "types", StringTypeInfo(min_length=1, arity=Arity.FromString('+')) ) ]), require_exact_match=True, arity=Arity.FromString('*')) ), ( "transformed_type_mappings", ClassTypeInfo(OrderedDict([ ( "input_type", StringTypeInfo(min_length=1) ), ( "is_input_optional", BoolTypeInfo(arity=Arity.FromString('?')) ), ( "transformed_type", StringTypeInfo(min_length=1) ), ( "is_output_optional", BoolTypeInfo(arity=Arity.FromString('?')) ) ]), require_exact_match=True, arity=Arity.FromString('+')) ) ]), require_exact_match=True, arity=Arity.FromString('+'))
 
-_featurizers_TypeInfo_Contents                                              = OrderedDict([("name", GenericTypeInfo()), ("estimator_name", GenericTypeInfo()), ("num_output_columns", GenericTypeInfo()), ("custom_structs", GenericTypeInfo(arity=Arity.FromString('*'))), ("configuration_params", GenericTypeInfo(arity=Arity.FromString('*'))), ("template", GenericTypeInfo(arity=Arity.FromString('?'))), ("input_type", GenericTypeInfo()), ("is_input_optional", GenericTypeInfo(arity=Arity.FromString('?'))), ("transformed_type", GenericTypeInfo()), ("is_output_optional", GenericTypeInfo(arity=Arity.FromString('?')))])
+_featurizers_TypeInfo_Contents                                              = OrderedDict([("name", GenericTypeInfo()), ("estimator_name", GenericTypeInfo()), ("num_output_columns", GenericTypeInfo()), ("custom_structs", GenericTypeInfo(arity=Arity.FromString('*'))), ("configuration_params", GenericTypeInfo(arity=Arity.FromString('*'))), ("templates", GenericTypeInfo(arity=Arity.FromString('*'))), ("transformed_type_mappings", GenericTypeInfo(arity=Arity.FromString('+')))])
 _featurizers_custom_structs_TypeInfo_Contents                               = OrderedDict([("name", GenericTypeInfo()), ("members", GenericTypeInfo(arity=Arity.FromString('+')))])
 _featurizers_custom_structs_members_TypeInfo_Contents                       = OrderedDict([("type", GenericTypeInfo()), ("name", GenericTypeInfo())])
 _featurizers_configuration_params_TypeInfo_Contents                         = OrderedDict([("type", GenericTypeInfo()), ("name", GenericTypeInfo()), ("is_optional", GenericTypeInfo(arity=Arity.FromString('?')))])
-_featurizers_template_TypeInfo_Contents                                     = OrderedDict([("name", GenericTypeInfo()), ("types", GenericTypeInfo(arity=Arity.FromString('+')))])
+_featurizers_templates_TypeInfo_Contents                                    = OrderedDict([("name", GenericTypeInfo()), ("types", GenericTypeInfo(arity=Arity.FromString('+')))])
+_featurizers_transformed_type_mappings_TypeInfo_Contents                    = OrderedDict([("input_type", GenericTypeInfo()), ("is_input_optional", GenericTypeInfo(arity=Arity.FromString('?'))), ("transformed_type", GenericTypeInfo()), ("is_output_optional", GenericTypeInfo(arity=Arity.FromString('?')))])
 
 _featurizers_TypeInfo                                                       = AnyOfTypeInfo([ClassTypeInfo(_featurizers_TypeInfo_Contents, require_exact_match=False), DictTypeInfo(_featurizers_TypeInfo_Contents, require_exact_match=False)], arity=Arity.FromString('+'))
 _featurizers_name_TypeInfo                                                  = StringTypeInfo(min_length=1)
@@ -169,13 +170,14 @@ _featurizers_configuration_params_TypeInfo                                  = An
 _featurizers_configuration_params_type_TypeInfo                             = StringTypeInfo(min_length=1)
 _featurizers_configuration_params_name_TypeInfo                             = StringTypeInfo(min_length=1)
 _featurizers_configuration_params_is_optional_TypeInfo                      = BoolTypeInfo(arity=Arity.FromString('?'))
-_featurizers_template_TypeInfo                                              = AnyOfTypeInfo([ClassTypeInfo(_featurizers_template_TypeInfo_Contents, require_exact_match=False), DictTypeInfo(_featurizers_template_TypeInfo_Contents, require_exact_match=False)], arity=Arity.FromString('?'))
-_featurizers_template_name_TypeInfo                                         = StringTypeInfo(min_length=1)
-_featurizers_template_types_TypeInfo                                        = StringTypeInfo(min_length=1, arity=Arity.FromString('+'))
-_featurizers_input_type_TypeInfo                                            = StringTypeInfo(min_length=1)
-_featurizers_is_input_optional_TypeInfo                                     = BoolTypeInfo(arity=Arity.FromString('?'))
-_featurizers_transformed_type_TypeInfo                                      = StringTypeInfo(min_length=1)
-_featurizers_is_output_optional_TypeInfo                                    = BoolTypeInfo(arity=Arity.FromString('?'))
+_featurizers_templates_TypeInfo                                             = AnyOfTypeInfo([ClassTypeInfo(_featurizers_templates_TypeInfo_Contents, require_exact_match=False), DictTypeInfo(_featurizers_templates_TypeInfo_Contents, require_exact_match=False)], arity=Arity.FromString('*'))
+_featurizers_templates_name_TypeInfo                                        = StringTypeInfo(min_length=1)
+_featurizers_templates_types_TypeInfo                                       = StringTypeInfo(min_length=1, arity=Arity.FromString('+'))
+_featurizers_transformed_type_mappings_TypeInfo                             = AnyOfTypeInfo([ClassTypeInfo(_featurizers_transformed_type_mappings_TypeInfo_Contents, require_exact_match=False), DictTypeInfo(_featurizers_transformed_type_mappings_TypeInfo_Contents, require_exact_match=False)], arity=Arity.FromString('+'))
+_featurizers_transformed_type_mappings_input_type_TypeInfo                  = StringTypeInfo(min_length=1)
+_featurizers_transformed_type_mappings_is_input_optional_TypeInfo           = BoolTypeInfo(arity=Arity.FromString('?'))
+_featurizers_transformed_type_mappings_transformed_type_TypeInfo            = StringTypeInfo(min_length=1)
+_featurizers_transformed_type_mappings_is_output_optional_TypeInfo          = BoolTypeInfo(arity=Arity.FromString('?'))
 
 # ----------------------------------------------------------------------
 # |
@@ -379,98 +381,123 @@ class Deserializer(object):
 
     # ----------------------------------------------------------------------
     @classmethod
-    def featurizers_template(cls, item, always_include_optional, process_additional_data):
-        if item in [DoesNotExist, None]:
-            _featurizers_template_TypeInfo.ValidateArity(None)
-            return DoesNotExist
-
-        result = cls._featurizers_template_Item(item, always_include_optional, process_additional_data)
-
-        _featurizers_template_TypeInfo.ValidateArity(result)
-
-        return result
-
-    # ----------------------------------------------------------------------
-    @classmethod
-    def featurizers_template_name(cls, item):
-        if item in [DoesNotExist, None]:
-            _featurizers_template_name_TypeInfo.ValidateArity(None)
-            return DoesNotExist
-
-        result = cls._featurizers_template_name_Item(item)
-
-        _featurizers_template_name_TypeInfo.ValidateArity(result)
-
-        return result
-
-    # ----------------------------------------------------------------------
-    @classmethod
-    def featurizers_template_types(cls, items):
+    def featurizers_templates(cls, items, always_include_optional, process_additional_data):
         if items in [DoesNotExist, None, []]:
-            _featurizers_template_types_TypeInfo.ValidateArity(None)
+            _featurizers_templates_TypeInfo.ValidateArity(None)
             return DoesNotExist
 
         results = []
 
         for this_index, this_item in enumerate(items or []):
             try:
-                results.append(cls._featurizers_template_types_Item(this_item))
+                results.append(cls._featurizers_templates_Item(this_item, always_include_optional, process_additional_data))
             except:
                 _DecorateActiveException("Index {}".format(this_index))
 
-        _featurizers_template_types_TypeInfo.ValidateArity(results)
+        _featurizers_templates_TypeInfo.ValidateArity(results)
 
         return results
 
     # ----------------------------------------------------------------------
     @classmethod
-    def featurizers_input_type(cls, item):
+    def featurizers_templates_name(cls, item):
         if item in [DoesNotExist, None]:
-            _featurizers_input_type_TypeInfo.ValidateArity(None)
+            _featurizers_templates_name_TypeInfo.ValidateArity(None)
             return DoesNotExist
 
-        result = cls._featurizers_input_type_Item(item)
+        result = cls._featurizers_templates_name_Item(item)
 
-        _featurizers_input_type_TypeInfo.ValidateArity(result)
+        _featurizers_templates_name_TypeInfo.ValidateArity(result)
 
         return result
 
     # ----------------------------------------------------------------------
     @classmethod
-    def featurizers_is_input_optional(cls, item):
-        if item in [DoesNotExist, None]:
-            _featurizers_is_input_optional_TypeInfo.ValidateArity(None)
+    def featurizers_templates_types(cls, items):
+        if items in [DoesNotExist, None, []]:
+            _featurizers_templates_types_TypeInfo.ValidateArity(None)
             return DoesNotExist
 
-        result = cls._featurizers_is_input_optional_Item(item)
+        results = []
 
-        _featurizers_is_input_optional_TypeInfo.ValidateArity(result)
+        for this_index, this_item in enumerate(items or []):
+            try:
+                results.append(cls._featurizers_templates_types_Item(this_item))
+            except:
+                _DecorateActiveException("Index {}".format(this_index))
+
+        _featurizers_templates_types_TypeInfo.ValidateArity(results)
+
+        return results
+
+    # ----------------------------------------------------------------------
+    @classmethod
+    def featurizers_transformed_type_mappings(cls, items, always_include_optional, process_additional_data):
+        if items in [DoesNotExist, None, []]:
+            _featurizers_transformed_type_mappings_TypeInfo.ValidateArity(None)
+            return DoesNotExist
+
+        results = []
+
+        for this_index, this_item in enumerate(items or []):
+            try:
+                results.append(cls._featurizers_transformed_type_mappings_Item(this_item, always_include_optional, process_additional_data))
+            except:
+                _DecorateActiveException("Index {}".format(this_index))
+
+        _featurizers_transformed_type_mappings_TypeInfo.ValidateArity(results)
+
+        return results
+
+    # ----------------------------------------------------------------------
+    @classmethod
+    def featurizers_transformed_type_mappings_input_type(cls, item):
+        if item in [DoesNotExist, None]:
+            _featurizers_transformed_type_mappings_input_type_TypeInfo.ValidateArity(None)
+            return DoesNotExist
+
+        result = cls._featurizers_transformed_type_mappings_input_type_Item(item)
+
+        _featurizers_transformed_type_mappings_input_type_TypeInfo.ValidateArity(result)
 
         return result
 
     # ----------------------------------------------------------------------
     @classmethod
-    def featurizers_transformed_type(cls, item):
+    def featurizers_transformed_type_mappings_is_input_optional(cls, item):
         if item in [DoesNotExist, None]:
-            _featurizers_transformed_type_TypeInfo.ValidateArity(None)
+            _featurizers_transformed_type_mappings_is_input_optional_TypeInfo.ValidateArity(None)
             return DoesNotExist
 
-        result = cls._featurizers_transformed_type_Item(item)
+        result = cls._featurizers_transformed_type_mappings_is_input_optional_Item(item)
 
-        _featurizers_transformed_type_TypeInfo.ValidateArity(result)
+        _featurizers_transformed_type_mappings_is_input_optional_TypeInfo.ValidateArity(result)
 
         return result
 
     # ----------------------------------------------------------------------
     @classmethod
-    def featurizers_is_output_optional(cls, item):
+    def featurizers_transformed_type_mappings_transformed_type(cls, item):
         if item in [DoesNotExist, None]:
-            _featurizers_is_output_optional_TypeInfo.ValidateArity(None)
+            _featurizers_transformed_type_mappings_transformed_type_TypeInfo.ValidateArity(None)
             return DoesNotExist
 
-        result = cls._featurizers_is_output_optional_Item(item)
+        result = cls._featurizers_transformed_type_mappings_transformed_type_Item(item)
 
-        _featurizers_is_output_optional_TypeInfo.ValidateArity(result)
+        _featurizers_transformed_type_mappings_transformed_type_TypeInfo.ValidateArity(result)
+
+        return result
+
+    # ----------------------------------------------------------------------
+    @classmethod
+    def featurizers_transformed_type_mappings_is_output_optional(cls, item):
+        if item in [DoesNotExist, None]:
+            _featurizers_transformed_type_mappings_is_output_optional_TypeInfo.ValidateArity(None)
+            return DoesNotExist
+
+        result = cls._featurizers_transformed_type_mappings_is_output_optional_Item(item)
+
+        _featurizers_transformed_type_mappings_is_output_optional_TypeInfo.ValidateArity(result)
 
         return result
 
@@ -533,56 +560,34 @@ class Deserializer(object):
         except:
             _DecorateActiveException("configuration_params")
 
-        # template
+        # templates
         try:
-            cls._ApplyOptionalChild(item, "template", result, lambda value: cls.featurizers_template(value, always_include_optional, process_additional_data), always_include_optional)
+            cls._ApplyOptionalChildren(item, "templates", result, lambda value: cls.featurizers_templates(value, always_include_optional, process_additional_data), always_include_optional)
         except:
-            _DecorateActiveException("template")
+            _DecorateActiveException("templates")
 
-        # input_type
+        # transformed_type_mappings
         try:
-            setattr(result, "input_type", cls.featurizers_input_type(
+            setattr(result, "transformed_type_mappings", cls.featurizers_transformed_type_mappings(
                 cls._GetPythonAttribute(
                     item,
-                    "input_type",
+                    "transformed_type_mappings",
                     is_optional=False,
                 ),
-            )
-            )
-        except:
-            _DecorateActiveException("input_type")
+                always_include_optional,
+                process_additional_data
 
-        # is_input_optional
-        try:
-            cls._ApplyOptionalChild(item, "is_input_optional", result, cls.featurizers_is_input_optional, always_include_optional, default_value_func=lambda: StringSerialization.DeserializeItem(_featurizers_is_input_optional_TypeInfo, "false"))
-        except:
-            _DecorateActiveException("is_input_optional")
-
-        # transformed_type
-        try:
-            setattr(result, "transformed_type", cls.featurizers_transformed_type(
-                cls._GetPythonAttribute(
-                    item,
-                    "transformed_type",
-                    is_optional=False,
-                ),
             )
             )
         except:
-            _DecorateActiveException("transformed_type")
-
-        # is_output_optional
-        try:
-            cls._ApplyOptionalChild(item, "is_output_optional", result, cls.featurizers_is_output_optional, always_include_optional, default_value_func=lambda: StringSerialization.DeserializeItem(_featurizers_is_output_optional_TypeInfo, "false"))
-        except:
-            _DecorateActiveException("is_output_optional")
+            _DecorateActiveException("transformed_type_mappings")
 
         # Additional data
         if process_additional_data:
             cls._ApplyAdditionalData(
                 item,
                 result,
-                exclude_names={"name", "estimator_name", "num_output_columns", "custom_structs", "configuration_params", "template", "input_type", "is_input_optional", "transformed_type", "is_output_optional"},
+                exclude_names={"name", "estimator_name", "num_output_columns", "custom_structs", "configuration_params", "templates", "transformed_type_mappings"},
             )
 
         _featurizers_TypeInfo.ValidateItem(
@@ -797,12 +802,12 @@ class Deserializer(object):
 
     # ----------------------------------------------------------------------
     @classmethod
-    def _featurizers_template_Item(cls, item, always_include_optional, process_additional_data):
+    def _featurizers_templates_Item(cls, item, always_include_optional, process_additional_data):
         attributes = OrderedDict()
 
         # name
         try:
-            attributes["name"] = cls.featurizers_template_name(
+            attributes["name"] = cls.featurizers_templates_name(
                 cls._GetPythonAttribute(
                     item,
                     "name",
@@ -818,7 +823,7 @@ class Deserializer(object):
 
         # types
         try:
-            setattr(result, "types", cls.featurizers_template_types(
+            setattr(result, "types", cls.featurizers_templates_types(
                 cls._GetPythonAttribute(
                     item,
                     "types",
@@ -837,7 +842,7 @@ class Deserializer(object):
                 exclude_names={"name", "types"},
             )
 
-        _featurizers_template_TypeInfo.ValidateItem(
+        _featurizers_templates_TypeInfo.ValidateItem(
             result,
             recurse=False,
             require_exact_match=not process_additional_data,
@@ -847,33 +852,94 @@ class Deserializer(object):
 
     # ----------------------------------------------------------------------
     @classmethod
-    def _featurizers_template_name_Item(cls, item):
-        return JsonSerialization.DeserializeItem(_featurizers_template_name_TypeInfo, item, **{})
+    def _featurizers_templates_name_Item(cls, item):
+        return JsonSerialization.DeserializeItem(_featurizers_templates_name_TypeInfo, item, **{})
 
     # ----------------------------------------------------------------------
     @classmethod
-    def _featurizers_template_types_Item(cls, item):
-        return JsonSerialization.DeserializeItem(_featurizers_template_types_TypeInfo, item, **{})
+    def _featurizers_templates_types_Item(cls, item):
+        return JsonSerialization.DeserializeItem(_featurizers_templates_types_TypeInfo, item, **{})
 
     # ----------------------------------------------------------------------
     @classmethod
-    def _featurizers_input_type_Item(cls, item):
-        return JsonSerialization.DeserializeItem(_featurizers_input_type_TypeInfo, item, **{})
+    def _featurizers_transformed_type_mappings_Item(cls, item, always_include_optional, process_additional_data):
+        result = _CreatePythonObject(
+            attributes=None,
+        )
+
+        # input_type
+        try:
+            setattr(result, "input_type", cls.featurizers_transformed_type_mappings_input_type(
+                cls._GetPythonAttribute(
+                    item,
+                    "input_type",
+                    is_optional=False,
+                ),
+            )
+            )
+        except:
+            _DecorateActiveException("input_type")
+
+        # is_input_optional
+        try:
+            cls._ApplyOptionalChild(item, "is_input_optional", result, cls.featurizers_transformed_type_mappings_is_input_optional, always_include_optional, default_value_func=lambda: StringSerialization.DeserializeItem(_featurizers_transformed_type_mappings_is_input_optional_TypeInfo, "false"))
+        except:
+            _DecorateActiveException("is_input_optional")
+
+        # transformed_type
+        try:
+            setattr(result, "transformed_type", cls.featurizers_transformed_type_mappings_transformed_type(
+                cls._GetPythonAttribute(
+                    item,
+                    "transformed_type",
+                    is_optional=False,
+                ),
+            )
+            )
+        except:
+            _DecorateActiveException("transformed_type")
+
+        # is_output_optional
+        try:
+            cls._ApplyOptionalChild(item, "is_output_optional", result, cls.featurizers_transformed_type_mappings_is_output_optional, always_include_optional, default_value_func=lambda: StringSerialization.DeserializeItem(_featurizers_transformed_type_mappings_is_output_optional_TypeInfo, "false"))
+        except:
+            _DecorateActiveException("is_output_optional")
+
+        # Additional data
+        if process_additional_data:
+            cls._ApplyAdditionalData(
+                item,
+                result,
+                exclude_names={"input_type", "is_input_optional", "transformed_type", "is_output_optional"},
+            )
+
+        _featurizers_transformed_type_mappings_TypeInfo.ValidateItem(
+            result,
+            recurse=False,
+            require_exact_match=not process_additional_data,
+        )
+
+        return result
 
     # ----------------------------------------------------------------------
     @classmethod
-    def _featurizers_is_input_optional_Item(cls, item):
-        return JsonSerialization.DeserializeItem(_featurizers_is_input_optional_TypeInfo, item, **{})
+    def _featurizers_transformed_type_mappings_input_type_Item(cls, item):
+        return JsonSerialization.DeserializeItem(_featurizers_transformed_type_mappings_input_type_TypeInfo, item, **{})
 
     # ----------------------------------------------------------------------
     @classmethod
-    def _featurizers_transformed_type_Item(cls, item):
-        return JsonSerialization.DeserializeItem(_featurizers_transformed_type_TypeInfo, item, **{})
+    def _featurizers_transformed_type_mappings_is_input_optional_Item(cls, item):
+        return JsonSerialization.DeserializeItem(_featurizers_transformed_type_mappings_is_input_optional_TypeInfo, item, **{})
 
     # ----------------------------------------------------------------------
     @classmethod
-    def _featurizers_is_output_optional_Item(cls, item):
-        return JsonSerialization.DeserializeItem(_featurizers_is_output_optional_TypeInfo, item, **{})
+    def _featurizers_transformed_type_mappings_transformed_type_Item(cls, item):
+        return JsonSerialization.DeserializeItem(_featurizers_transformed_type_mappings_transformed_type_TypeInfo, item, **{})
+
+    # ----------------------------------------------------------------------
+    @classmethod
+    def _featurizers_transformed_type_mappings_is_output_optional_Item(cls, item):
+        return JsonSerialization.DeserializeItem(_featurizers_transformed_type_mappings_is_output_optional_TypeInfo, item, **{})
 
     # ----------------------------------------------------------------------
     # ----------------------------------------------------------------------
diff --git a/src/FeaturizerPrep/Tools/CodeGenerator/SchemaBuildEnvironment/bootstrap_impl.py b/src/FeaturizerPrep/Tools/CodeGenerator/SchemaBuildEnvironment/bootstrap_impl.py
index b8fc78a..4725c8d 100644
--- a/src/FeaturizerPrep/Tools/CodeGenerator/SchemaBuildEnvironment/bootstrap_impl.py
+++ b/src/FeaturizerPrep/Tools/CodeGenerator/SchemaBuildEnvironment/bootstrap_impl.py
@@ -48,8 +48,6 @@ _REPO_DATA                                  = [
 
 _ACTIVATION_REPO_CONFIGURATION              = "python"  # Can be None
 
-raise Exception("Remove this exception when '_REPO_DATA', '_ACTIVATION_REPO_CONFIGURATION' have been updated for your environment")
-
 # ----------------------------------------------------------------------
 inflect                                     = inflect_mod.engine()
 
diff --git a/src/FeaturizerPrep/Tools/CodeGenerator/__main__.py b/src/FeaturizerPrep/Tools/CodeGenerator/__main__.py
index 457086f..d9a3610 100644
--- a/src/FeaturizerPrep/Tools/CodeGenerator/__main__.py
+++ b/src/FeaturizerPrep/Tools/CodeGenerator/__main__.py
@@ -112,32 +112,51 @@ def EntryPoint(
             new_data = []
 
             for item in data:
-                if not hasattr(item, "template"):
-                    new_data.append([item])
+                if not hasattr(item, "templates"):
+                    for mapping in item.transformed_type_mappings:
+                        new_item = copy.deepcopy(item)
+
+                        new_item.input_type = mapping.input_type
+                        new_item.transformed_type = mapping.transformed_type
+                        new_item.is_input_optional = mapping.is_input_optional
+                        new_item.is_output_optional = mapping.is_output_optional
+                        
+                        new_data.append([new_item])
                     continue
-
-                regex = re.compile(r"\b{}\b".format(item.template.name))
-
                 new_data_items = []
+                for template in item.templates:
+                    regex = re.compile(r"\b{}\b".format(template.name))
 
-                for template_type in item.template.types:
-                    new_item = copy.deepcopy(item)
-                    new_item.template = template_type
+                    for template_type in template.types:
+                        new_item = copy.deepcopy(item)
+                        new_item.template = template_type
 
-                    for configuration_param in getattr(new_item, "configuration_params", []):
-                        configuration_param.type = regex.sub(template_type, configuration_param.type)
+                        # Remove the template mapping and list of templates
+                        del new_item.templates
+                        del new_item.transformed_type_mappings
 
-                    new_item.input_type = regex.sub(template_type, new_item.input_type)
-                    new_item.transformed_type = regex.sub(template_type, new_item.transformed_type)
+                        for configuration_param in getattr(new_item, "configuration_params", []):
+                            configuration_param.type = regex.sub(template_type, configuration_param.type)
 
-                    for custom_struct in getattr(new_item, "custom_structs", []):
-                        for member in custom_struct.members:
-                            member.type = regex.sub(template_type, member.type)
+                        for custom_struct in getattr(new_item, "custom_structs", []):
+                            for member in custom_struct.members:
+                                member.type = regex.sub(template_type, member.type)
 
-                    new_data_items.append(new_item)
+                        for mapping in item.transformed_type_mappings:
+                            # Since we can have multiple templates this is for when a mapping doesn't use a template or not the current template
+                            if mapping.input_type != template.name and mapping.transformed_type != template.name:
+                                continue
+                            
+                            new_item.input_type = regex.sub(template_type, mapping.input_type)
+                            new_item.transformed_type = regex.sub(template_type, mapping.transformed_type)
+                            new_item.is_input_optional = mapping.is_input_optional
+                            new_item.is_output_optional = mapping.is_output_optional
+
+                            # This will end up copying one more time than needed, but I couldn't think of a better way for now.
+                            new_data_items.append(copy.deepcopy(new_item))
 
                 new_data.append(new_data_items)
-
+            
             data = new_data
 
         dm.stream.write("Generating content...")