diff --git a/six/modules/c++/cphd/include/cphd/PVPBlock.h b/six/modules/c++/cphd/include/cphd/PVPBlock.h
index 7981e3312..e65da144a 100644
--- a/six/modules/c++/cphd/include/cphd/PVPBlock.h
+++ b/six/modules/c++/cphd/include/cphd/PVPBlock.h
@@ -61,13 +61,23 @@ struct AddedPVP
     }
 };
 template<typename T>
-struct AddedPVP<types::complex<T> >
+struct AddedPVP<std::complex<T>>
 {
-    types::complex<T> getAddedPVP(const six::Parameter& val) const
+    auto getAddedPVP(const six::Parameter& val) const
     {
         return val.getComplex<T>();
     }
 };
+//#if CODA_OSS_types_unique_zinteger 
+//template<typename T>
+//struct AddedPVP<types::zinteger<T> >
+//{
+//    auto getAddedPVP(const six::Parameter& val) const
+//    {
+//        return val.getComplex<T>();
+//    }
+//};
+//#endif
 template<>
 struct AddedPVP<std::string>
 {
diff --git a/six/modules/c++/cphd/include/cphd/Types.h b/six/modules/c++/cphd/include/cphd/Types.h
index 81873ffcb..042d0485c 100644
--- a/six/modules/c++/cphd/include/cphd/Types.h
+++ b/six/modules/c++/cphd/include/cphd/Types.h
@@ -42,11 +42,11 @@ namespace cphd
 
 using zfloat = six::zfloat;
 using zdouble = six::zdouble;
+using zint16_t = six::zint16_t;
 
-using zint8_t = types::zint8_t;
-using zint16_t = types::zint16_t;
-using zint32_t = types::zint32_t;
-using zint64_t = types::zint64_t;
+using zint8_t = std::complex<int8_t>; // TODO: types::zint8_t;
+using zint32_t = std::complex<int32_t>; // TODO: types::zint32_t;
+using zint64_t = std::complex<int64_t>; // TODO: types::zint64_t;
 
 typedef six::Vector2 Vector2;
 
diff --git a/six/modules/c++/cphd/source/ByteSwap.cpp b/six/modules/c++/cphd/source/ByteSwap.cpp
index 978e1c98d..642c9a775 100644
--- a/six/modules/c++/cphd/source/ByteSwap.cpp
+++ b/six/modules/c++/cphd/source/ByteSwap.cpp
@@ -29,6 +29,7 @@
 #include <std/span>
 #include <std/cstddef>
 #include <tuple>
+#include <type_traits>
 
 #include <types/complex.h>
 #include <sys/Conf.h>
@@ -41,6 +42,8 @@
 #include <mt/ThreadedByteSwap.h>
 #include <nitf/coda-oss.hpp>
 
+#include <cphd/Types.h>
+
 namespace
 {
 template <typename T>
@@ -56,7 +59,7 @@ inline const std::byte* calc_offset(const void* input_, size_t offset)
     return input + offset;
 }
 
-template <typename InT>
+template <typename ComplexInT>
 struct ByteSwapAndPromoteRunnable final : public sys::Runnable
 {
     ByteSwapAndPromoteRunnable(const void* input,
@@ -64,7 +67,7 @@ struct ByteSwapAndPromoteRunnable final : public sys::Runnable
                              size_t numRows,
                              size_t numCols,
                              cphd::zfloat* output) :
-        mInput(calc_offset(input, startRow * numCols * sizeof(types::complex<InT>))),
+        mInput(calc_offset(input, startRow * numCols * sizeof(ComplexInT))),
         mDims(numRows, numCols),
         mOutput(output + startRow * numCols)
     {
@@ -72,19 +75,20 @@ struct ByteSwapAndPromoteRunnable final : public sys::Runnable
 
     void run() override
     {
-        InT real(0);
-        InT imag(0);
+        using value_type = typename ComplexInT::value_type;
+        value_type real(0);
+        value_type imag(0);
 
         for (size_t row = 0, inIdx = 0, outIdx = 0; row < mDims.row; ++row)
         {
-            for (size_t col = 0; col < mDims.col; ++col, inIdx += sizeof(types::complex<InT>), ++outIdx)
+            for (size_t col = 0; col < mDims.col; ++col, inIdx += sizeof(ComplexInT), ++outIdx)
             {
                 // Have to be careful here - can't treat mInput as a
-                // types::complex<InT> directly in case InT is a float (see
+                // std::complex_t<InT> directly in case InT is a float (see
                 // explanation in byteSwap() comments)
                 const auto input = calc_offset(mInput, inIdx);
                 byteSwap(input, real);
-                byteSwap(calc_offset(input, sizeof(InT)), imag);
+                byteSwap(calc_offset(input, sizeof(value_type)), imag);
 
                 mOutput[outIdx] = cphd::zfloat(real, imag);
             }
@@ -98,7 +102,7 @@ struct ByteSwapAndPromoteRunnable final : public sys::Runnable
 };
 
 
-template <typename InT>
+template <typename ComplexInT>
 struct ByteSwapAndScaleRunnable final : public sys::Runnable
 {
     ByteSwapAndScaleRunnable(const void* input,
@@ -107,7 +111,7 @@ struct ByteSwapAndScaleRunnable final : public sys::Runnable
                              size_t numCols,
                              const double* scaleFactors,
                              cphd::zfloat* output) :
-        mInput(calc_offset(input, startRow * numCols * sizeof(types::complex<InT>))),
+        mInput(calc_offset(input, startRow * numCols * sizeof(ComplexInT))),
         mDims(numRows, numCols),
         mScaleFactors(scaleFactors + startRow),
         mOutput(output + startRow * numCols)
@@ -116,8 +120,9 @@ struct ByteSwapAndScaleRunnable final : public sys::Runnable
 
     void run() override
     {
-        InT real(0);
-        InT imag(0);
+        using value_type = typename ComplexInT::value_type;
+        value_type real(0);
+        value_type imag(0);
 
         for (size_t row = 0, inIdx = 0, outIdx = 0; row < mDims.row; ++row)
         {
@@ -125,14 +130,14 @@ struct ByteSwapAndScaleRunnable final : public sys::Runnable
 
             for (size_t col = 0;
                  col < mDims.col;
-                 ++col, inIdx += sizeof(types::complex<InT>), ++outIdx)
+                 ++col, inIdx += sizeof(ComplexInT), ++outIdx)
             {
                 // Have to be careful here - can't treat mInput as a
-                // types::complex<InT> directly in case InT is a float (see
+                // std::ComplexInT directly in case InT is a float (see
                 // explanation in byteSwap() comments)
                 const auto input = calc_offset(mInput, inIdx);
                 byteSwap(input, real);
-                byteSwap(calc_offset(input, sizeof(InT)), imag);
+                byteSwap(calc_offset(input, sizeof(value_type)), imag);
 
                 mOutput[outIdx] = cphd::zfloat(
                         static_cast<float>(real * scaleFactor),
@@ -148,7 +153,7 @@ struct ByteSwapAndScaleRunnable final : public sys::Runnable
     cphd::zfloat* const mOutput;
 };
 
-template <typename InT>
+template <typename ComplexInT>
 void byteSwapAndPromote(const void* input,
                       const types::RowCol<size_t>& dims,
                       size_t numThreads,
@@ -156,7 +161,7 @@ void byteSwapAndPromote(const void* input,
 {
     if (numThreads <= 1)
     {
-        ByteSwapAndPromoteRunnable<InT>(input, 0, dims.row, dims.col,output).run();
+        ByteSwapAndPromoteRunnable<ComplexInT>(input, 0, dims.row, dims.col,output).run();
     }
     else
     {
@@ -170,7 +175,7 @@ void byteSwapAndPromote(const void* input,
                                      startRow,
                                      numRowsThisThread))
         {
-            auto scaler = std::make_unique<ByteSwapAndPromoteRunnable<InT>>(
+            auto scaler = std::make_unique<ByteSwapAndPromoteRunnable<ComplexInT>>(
                     input,
                     startRow,
                     numRowsThisThread,
@@ -238,13 +243,13 @@ void byteSwapAndPromote(const void* input,
     switch (elementSize)
     {
     case 2:
-        ::byteSwapAndPromote<int8_t>(input, dims, numThreads, output);
+        ::byteSwapAndPromote<cphd::zint8_t>(input, dims, numThreads, output);
         break;
     case 4:
-        ::byteSwapAndPromote<int16_t>(input, dims, numThreads, output);
+        ::byteSwapAndPromote<cphd::zint16_t>(input, dims, numThreads, output);
         break;
     case 8:
-        ::byteSwapAndPromote<float>(input, dims, numThreads, output);
+        ::byteSwapAndPromote<cphd::zfloat>(input, dims, numThreads, output);
         break;
     default:
         throw except::Exception(Ctxt(
@@ -262,15 +267,15 @@ void byteSwapAndScale(const void* input,
     switch (elementSize)
     {
     case 2:
-        ::byteSwapAndScale<int8_t>(input, dims, scaleFactors, numThreads,
+        ::byteSwapAndScale<cphd::zint8_t>(input, dims, scaleFactors, numThreads,
                                         output);
         break;
     case 4:
-        ::byteSwapAndScale<int16_t>(input, dims, scaleFactors, numThreads,
+        ::byteSwapAndScale<cphd::zint16_t>(input, dims, scaleFactors, numThreads,
                                          output);
         break;
     case 8:
-        ::byteSwapAndScale<float>(input, dims, scaleFactors, numThreads,
+        ::byteSwapAndScale<cphd::zfloat>(input, dims, scaleFactors, numThreads,
                                   output);
         break;
     default:
diff --git a/six/modules/c++/cphd/source/PVPBlock.cpp b/six/modules/c++/cphd/source/PVPBlock.cpp
index c94677ab5..fdae548e8 100644
--- a/six/modules/c++/cphd/source/PVPBlock.cpp
+++ b/six/modules/c++/cphd/source/PVPBlock.cpp
@@ -309,6 +309,15 @@ void PVPBlock::PVPSet::write(const PVPBlock& pvpBlock, const Pvp& p, const sys::
     }
 }
 
+template<typename TComplex>
+auto findComplex(const std::unordered_map<std::string, six::Parameter>& addedPVP, std::map<std::string, APVPType>::const_iterator it)
+{
+    using value_type = typename TComplex::value_type; // help the compiler find the right overload
+    TComplex retval;
+    addedPVP.find(it->first)->second.getComplex<value_type>(retval);
+    return retval;
+}
+
 void PVPBlock::PVPSet::read(const Pvp& p, sys::ubyte* dest_) const
 {
     auto dest = reinterpret_cast<std::byte*>(dest_);
@@ -407,27 +416,27 @@ void PVPBlock::PVPSet::read(const Pvp& p, sys::ubyte* dest_) const
         }
         else if (it->second.getFormat() == "CI2")
         {
-            ::getData(dest + it->second.getByteOffset(), addedPVP.find(it->first)->second.getComplex<std::int8_t>());
+            ::getData(dest + it->second.getByteOffset(), findComplex<cphd::zint8_t>(addedPVP, it));
         }
         else if (it->second.getFormat() == "CI4")
         {
-            ::getData(dest + it->second.getByteOffset(), addedPVP.find(it->first)->second.getComplex<std::int16_t>());
+            ::getData(dest + it->second.getByteOffset(), findComplex<cphd::zint16_t>(addedPVP, it));
         }
         else if (it->second.getFormat() == "CI8")
         {
-            ::getData(dest + it->second.getByteOffset(), addedPVP.find(it->first)->second.getComplex<std::int32_t>());
+            ::getData(dest + it->second.getByteOffset(), findComplex<cphd::zint32_t>(addedPVP, it));
         }
         else if (it->second.getFormat() == "CI16")
         {
-            ::getData(dest + it->second.getByteOffset(), addedPVP.find(it->first)->second.getComplex<std::int64_t>());
+            ::getData(dest + it->second.getByteOffset(), findComplex<cphd::zint64_t>(addedPVP, it));
         }
         else if (it->second.getFormat() == "CF8")
         {
-            ::getData(dest + it->second.getByteOffset(), addedPVP.find(it->first)->second.getComplex<float>());
+            ::getData(dest + it->second.getByteOffset(), findComplex<cphd::zfloat>(addedPVP, it));
         }
         else if (it->second.getFormat() == "CF16")
         {
-            ::getData(dest + it->second.getByteOffset(), addedPVP.find(it->first)->second.getComplex<double>());
+            ::getData(dest + it->second.getByteOffset(), findComplex<cphd::zdouble>(addedPVP, it));
         }
         else
         {
diff --git a/six/modules/c++/cphd/source/Wideband.cpp b/six/modules/c++/cphd/source/Wideband.cpp
index a2a50d48b..adfe8e46f 100644
--- a/six/modules/c++/cphd/source/Wideband.cpp
+++ b/six/modules/c++/cphd/source/Wideband.cpp
@@ -25,6 +25,7 @@
 #include <thread>
 #include <string>
 #include <memory>
+#include <type_traits>
 
 #include <types/complex.h>
 #include <except/Exception.h>
@@ -38,17 +39,17 @@
 #include <cphd/ByteSwap.h>
 #include <cphd/Wideband.h>
 #include <cphd/FileHeader.h>
+#include <cphd/Types.h>
 
 #undef min
 #undef max
 
 namespace
 {
-template <typename InT>
-class PromoteRunnable : public sys::Runnable
+template <typename ComplexInT>
+struct PromoteRunnable final : public sys::Runnable
 {
-public:
-    PromoteRunnable(const types::complex<InT>* input,
+    PromoteRunnable(const ComplexInT* input,
                     size_t startRow,
                     size_t numRows,
                     size_t numCols,
@@ -65,23 +66,22 @@ class PromoteRunnable : public sys::Runnable
         {
             for (size_t col = 0; col < mDims.col; ++col, ++idx)
             {
-                const types::complex<InT>& input(mInput[idx]);
+                const ComplexInT& input(mInput[idx]);
                 mOutput[idx] = cphd::zfloat(input.real(), input.imag());
             }
         }
     }
 
 private:
-    const types::complex<InT>* const mInput;
+    const ComplexInT* const mInput;
     const types::RowCol<size_t> mDims;
     cphd::zfloat* const mOutput;
 };
 
-template <typename InT>
-class ScaleRunnable : public sys::Runnable
+template <typename ComplexInT>
+struct ScaleRunnable final : public sys::Runnable
 {
-public:
-    ScaleRunnable(const types::complex<InT>* input,
+    ScaleRunnable(const ComplexInT* input,
                   size_t startRow,
                   size_t numRows,
                   size_t numCols,
@@ -101,7 +101,7 @@ class ScaleRunnable : public sys::Runnable
             const double scaleFactor(mScaleFactors[row]);
             for (size_t col = 0; col < mDims.col; ++col, ++idx)
             {
-                const types::complex<InT>& input(mInput[idx]);
+                auto&& input(mInput[idx]);
                 mOutput[idx] = cphd::zfloat(static_cast<float>(input.real() * scaleFactor),
                                                    static_cast<float>(input.imag() * scaleFactor));
             }
@@ -109,13 +109,13 @@ class ScaleRunnable : public sys::Runnable
     }
 
 private:
-    const types::complex<InT>* const mInput;
+    const ComplexInT* const mInput;
     const types::RowCol<size_t> mDims;
     const double* const mScaleFactors;
     cphd::zfloat* const mOutput;
 };
 
-template <typename InT>
+template <typename ComplexInT>
 void promote(const void* input,
              const types::RowCol<size_t>& dims,
              size_t numThreads,
@@ -123,7 +123,7 @@ void promote(const void* input,
 {
     if (numThreads <= 1)
     {
-        PromoteRunnable<InT>(static_cast<const types::complex<InT>*>(input),
+        PromoteRunnable<ComplexInT>(static_cast<const ComplexInT*>(input),
                              0,
                              dims.row,
                              dims.col,
@@ -140,8 +140,8 @@ void promote(const void* input,
         size_t numRowsThisThread(0);
         while (planner.getThreadInfo(threadNum++, startRow, numRowsThisThread))
         {
-           auto scaler = std::make_unique<PromoteRunnable<InT>>(
-                    static_cast<const types::complex<InT>*>(input),
+           auto scaler = std::make_unique<PromoteRunnable<ComplexInT>>(
+                    static_cast<const ComplexInT*>(input),
                     startRow,
                     numRowsThisThread,
                     dims.col,
@@ -162,20 +162,20 @@ void promote(const void* input,
     switch (elementSize)
     {
     case 2:
-        promote<int8_t>(input, dims, numThreads, output);
+        promote<cphd::zint8_t>(input, dims, numThreads, output);
         break;
     case 4:
-        promote<int16_t>(input, dims, numThreads, output);
+        promote<cphd::zint16_t>(input, dims, numThreads, output);
         break;
     case 8:
-        promote<float>(input, dims, numThreads, output);
+        promote<cphd::zfloat>(input, dims, numThreads, output);
         break;
     default:
         throw except::Exception(
                 Ctxt("Unexpected element size " + std::to_string(elementSize)));
     }
 }
-template <typename InT>
+template <typename ComplexInT>
 void scale(const void* input,
            const types::RowCol<size_t>& dims,
            const double* scaleFactors,
@@ -184,7 +184,7 @@ void scale(const void* input,
 {
     if (numThreads <= 1)
     {
-        ScaleRunnable<InT>(static_cast<const types::complex<InT>*>(input),
+        ScaleRunnable<ComplexInT>(static_cast<const ComplexInT*>(input),
                            0,
                            dims.row,
                            dims.col,
@@ -202,8 +202,8 @@ void scale(const void* input,
         size_t numRowsThisThread(0);
         while (planner.getThreadInfo(threadNum++, startRow, numRowsThisThread))
         {
-           auto scaler = std::make_unique<ScaleRunnable<InT>>(
-                    static_cast<const types::complex<InT>*>(input),
+           auto scaler = std::make_unique<ScaleRunnable<ComplexInT>>(
+                    static_cast<const ComplexInT*>(input),
                     startRow,
                     numRowsThisThread,
                     dims.col,
@@ -226,13 +226,13 @@ void scale(const void* input,
     switch (elementSize)
     {
     case 2:
-        scale<int8_t>(input, dims, scaleFactors, numThreads, output);
+        scale<cphd::zint8_t>(input, dims, scaleFactors, numThreads, output);
         break;
     case 4:
-        scale<int16_t>(input, dims, scaleFactors, numThreads, output);
+        scale<cphd::zint16_t>(input, dims, scaleFactors, numThreads, output);
         break;
     case 8:
-        scale<float>(input, dims, scaleFactors, numThreads, output);
+        scale<cphd::zfloat>(input, dims, scaleFactors, numThreads, output);
         break;
     default:
         throw except::Exception(
diff --git a/six/modules/c++/cphd/unittests/test_pvp_block_round.cpp b/six/modules/c++/cphd/unittests/test_pvp_block_round.cpp
index 026f6c351..3bb70ad50 100644
--- a/six/modules/c++/cphd/unittests/test_pvp_block_round.cpp
+++ b/six/modules/c++/cphd/unittests/test_pvp_block_round.cpp
@@ -42,16 +42,17 @@
 #include <stdexcept>
 #include <string>
 
-template <typename T>
-std::vector<types::complex<T>> generateComplexData(size_t length)
+template <typename TComplex>
+auto generateComplexData(size_t length)
 {
-    std::vector<types::complex<T>> data(length);
+    using value_type = typename TComplex::value_type;
+    std::vector<TComplex> data(length);
     srand(0);
     for (size_t ii = 0; ii < data.size(); ++ii)
     {
-        float real = static_cast<T>(rand() / 100);
-        float imag = static_cast<T>(rand() / 100);
-        data[ii] = types::complex<T>(real, imag);
+        auto real = static_cast<value_type>(rand() / 100);
+        auto imag = static_cast<value_type>(rand() / 100);
+        data[ii] = TComplex(real, imag);
     }
     return data;
 }
@@ -115,11 +116,11 @@ void setPVPBlock(const types::RowCol<size_t> dims,
     }
 }
 
-template <typename T>
+template <typename TCxVector>
 void writeCPHD(const std::string& outPathname,
                size_t numThreads,
                const types::RowCol<size_t> dims,
-               const std::vector<types::complex<T>>& writeData,
+               const TCxVector& writeData,
                cphd::Metadata& metadata,
                cphd::PVPBlock& pvpBlock)
 {
@@ -155,9 +156,9 @@ bool checkData(const std::string& pathname,
     return true;
 }
 
-template <typename T>
+template <typename TCxVector>
 bool runTest(bool /*scale*/,
-             const std::vector<types::complex<T>>& writeData,
+             const TCxVector& writeData,
              cphd::Metadata& meta,
              cphd::PVPBlock& pvpBlock,
              const types::RowCol<size_t> dims)
@@ -171,8 +172,7 @@ bool runTest(bool /*scale*/,
 TEST_CASE(testPVPBlockSimple)
 {
     const types::RowCol<size_t> dims(128, 256);
-    const std::vector<cphd::zint16_t> writeData =
-            generateComplexData<int16_t>(dims.area());
+    const auto writeData = generateComplexData<cphd::zint16_t>(dims.area());
     const bool scale = false;
     cphd::Metadata meta = cphd::Metadata();
     cphd::setUpData(meta, dims, writeData);
@@ -195,8 +195,7 @@ TEST_CASE(testPVPBlockSimple)
 TEST_CASE(testPVPBlockOptional)
 {
     const types::RowCol<size_t> dims(128, 256);
-    const std::vector<cphd::zint16_t> writeData =
-            generateComplexData<int16_t>(dims.area());
+    const auto writeData = generateComplexData<cphd::zint16_t>(dims.area());
     const bool scale = false;
     cphd::Metadata meta = cphd::Metadata();
     cphd::setUpData(meta, dims, writeData);
@@ -222,8 +221,7 @@ TEST_CASE(testPVPBlockOptional)
 TEST_CASE(testPVPBlockAdditional)
 {
     const types::RowCol<size_t> dims(128, 256);
-    const std::vector<cphd::zint16_t> writeData =
-            generateComplexData<int16_t>(dims.area());
+    const auto writeData = generateComplexData<cphd::zint16_t>(dims.area());
     const bool scale = false;
     cphd::Metadata meta = cphd::Metadata();
     cphd::setUpData(meta, dims, writeData);
diff --git a/six/modules/c++/cphd/unittests/test_signal_block_round.cpp b/six/modules/c++/cphd/unittests/test_signal_block_round.cpp
index 5eaeb9fd7..197bc1069 100644
--- a/six/modules/c++/cphd/unittests/test_signal_block_round.cpp
+++ b/six/modules/c++/cphd/unittests/test_signal_block_round.cpp
@@ -46,16 +46,17 @@
  * Fails if values don't match
  */
 
-template<typename T>
-std::vector<types::complex<T> > generateData(size_t length)
+template<typename TComplex>
+auto generateData(size_t length)
 {
-    std::vector<types::complex<T> > data(length);
+    using value_type = typename TComplex::value_type;
+    std::vector<TComplex> data(length);
     srand(0);
     for (size_t ii = 0; ii < data.size(); ++ii)
     {
-        auto real = static_cast<T>(rand() / 100);
-        auto imag = static_cast<T>(rand() / 100);
-        data[ii] = types::complex<T>(real, imag);
+        auto real = static_cast<value_type>(rand() / 100);
+        auto imag = static_cast<value_type>(rand() / 100);
+        data[ii] = TComplex(real, imag);
     }
     return data;
 }
@@ -73,10 +74,10 @@ inline std::vector<double> generateScaleFactors(size_t length, bool scale)
     return scaleFactors;
 }
 
-template<typename T>
+template<typename TCxVector>
 void writeCPHD(const std::string& outPathname, size_t /*numThreads*/,
         const types::RowCol<size_t> dims,
-        const std::vector<types::complex<T> >& writeData,
+        const TCxVector& writeData,
         cphd::Metadata& metadata,
         cphd::PVPBlock& pvpBlock)
 {
@@ -120,9 +121,9 @@ std::vector<cphd::zfloat > checkData(const std::string& pathname,
     return readData;
 }
 
-template<typename T>
+template<typename TCxVector>
 bool compareVectors(const std::vector<cphd::zfloat >& readData,
-                    const std::vector<types::complex<T> >& writeData,
+                    const TCxVector& writeData,
                     const std::vector<double>& scaleFactors,
                     bool scale)
 {
@@ -144,8 +145,8 @@ bool compareVectors(const std::vector<cphd::zfloat >& readData,
     return true;
 }
 
-template<typename T>
-bool runTest(bool scale, const std::vector<types::complex<T> >& writeData)
+template<typename TCxVector>
+bool runTest(bool scale, const TCxVector& writeData)
 {
     io::TempFile tempfile;
     const size_t numThreads = std::thread::hardware_concurrency();
@@ -168,8 +169,7 @@ bool runTest(bool scale, const std::vector<types::complex<T> >& writeData)
 TEST_CASE(testUnscaledInt8)
 {
     const types::RowCol<size_t> dims(128, 128);
-    const std::vector<cphd::zint8_t > writeData =
-            generateData<int8_t>(dims.area());
+    const auto writeData = generateData<cphd::zint8_t>(dims.area());
     const bool scale = false;
     TEST_ASSERT_TRUE(runTest(scale, writeData));
 }
@@ -177,8 +177,7 @@ TEST_CASE(testUnscaledInt8)
 TEST_CASE(testScaledInt8)
 {
     const types::RowCol<size_t> dims(128, 128);
-    const std::vector<cphd::zint8_t > writeData =
-            generateData<int8_t>(dims.area());
+    const auto writeData = generateData<cphd::zint8_t>(dims.area());
     const bool scale = true;
     TEST_ASSERT_TRUE(runTest(scale, writeData));
 }
@@ -186,8 +185,7 @@ TEST_CASE(testScaledInt8)
 TEST_CASE(testUnscaledInt16)
 {
     const types::RowCol<size_t> dims(128, 128);
-    const std::vector<cphd::zint16_t > writeData =
-            generateData<int16_t>(dims.area());
+    const auto writeData = generateData<cphd::zint16_t>(dims.area());
     const bool scale = false;
     TEST_ASSERT_TRUE(runTest(scale, writeData));
 }
@@ -195,8 +193,7 @@ TEST_CASE(testUnscaledInt16)
 TEST_CASE(testScaledInt16)
 {
     const types::RowCol<size_t> dims(128, 128);
-    const std::vector<cphd::zint16_t > writeData =
-            generateData<int16_t>(dims.area());
+    const auto writeData =  generateData<cphd::zint16_t>(dims.area());
     const bool scale = true;
     TEST_ASSERT_TRUE(runTest(scale, writeData));
 }
@@ -204,8 +201,7 @@ TEST_CASE(testScaledInt16)
 TEST_CASE(testUnscaledFloat)
 {
     const types::RowCol<size_t> dims(128, 128);
-    const std::vector<cphd::zfloat > writeData =
-            generateData<float>(dims.area());
+    const auto writeData = generateData<cphd::zfloat>(dims.area());
     const bool scale = false;
     TEST_ASSERT_TRUE(runTest(scale, writeData));
 }
@@ -213,8 +209,7 @@ TEST_CASE(testUnscaledFloat)
 TEST_CASE(testScaledFloat)
 {
     const types::RowCol<size_t> dims(128, 128);
-    const std::vector<cphd::zfloat > writeData =
-            generateData<float>(dims.area());
+    const auto writeData = generateData<cphd::zfloat>(dims.area());
     const bool scale = true;
     TEST_ASSERT_TRUE(runTest(scale, writeData));
 }
diff --git a/six/modules/c++/cphd03/unittests/test_cphd_read_unscaled_int.cpp b/six/modules/c++/cphd03/unittests/test_cphd_read_unscaled_int.cpp
index 704517da6..55ba57554 100644
--- a/six/modules/c++/cphd03/unittests/test_cphd_read_unscaled_int.cpp
+++ b/six/modules/c++/cphd03/unittests/test_cphd_read_unscaled_int.cpp
@@ -37,16 +37,17 @@
 
 #include "TestCase.h"
 
-template<typename T>
-std::vector<types::complex<T> > generateData(size_t length)
+template<typename TComplex>
+auto generateData(size_t length)
 {
-    std::vector<types::complex<T> > data(length);
+    using value_type = typename TComplex::value_type;
+    std::vector<TComplex> data(length);
     srand(0);
     for (size_t ii = 0; ii < data.size(); ++ii)
     {
-        float real = static_cast<T>(rand() / 100);
-        float imag = static_cast<T>(rand() / 100);
-        data[ii] = types::complex<T>(real, imag);
+        auto real = static_cast<value_type>(rand() / 100);
+        auto imag = static_cast<value_type>(rand() / 100);
+        data[ii] = TComplex(real, imag);
     }
     return data;
 }
@@ -84,10 +85,10 @@ inline cphd::SampleType getSampleType(size_t writeDataSize)
     throw std::invalid_argument("Unespced writeDataSize");
 }
 
-template<typename T>
+template<typename TCxVector>
 void writeCPHD(const std::string& outPathname, size_t numThreads,
         const types::RowCol<size_t> dims,
-        const std::vector<types::complex<T> >& writeData)
+        const TCxVector& writeData)
 {
     const size_t numChannels = 1;
     const std::vector<size_t> numVectors(numChannels, dims.row);
@@ -164,9 +165,9 @@ std::vector<cphd::zfloat > checkData(const std::string& pathname,
     return readData;
 }
 
-template<typename T>
+template<typename TCxVector>
 bool compareVectors(const std::vector<cphd::zfloat >& readData,
-                    const std::vector<types::complex<T> >& writeData,
+                    const TCxVector& writeData,
                     const std::vector<double>& scaleFactors,
                     bool scale)
 {
@@ -188,26 +189,23 @@ bool compareVectors(const std::vector<cphd::zfloat >& readData,
     return true;
 }
 
-template<typename T>
-bool runTest(bool scale, const std::vector<types::complex<T> >& writeData)
+template<typename TCxVector>
+bool runTest(bool scale, const TCxVector& writeData)
 {
     io::TempFile tempfile;
     const size_t numThreads = std::thread::hardware_concurrency();
     const types::RowCol<size_t> dims(128, 128);
-    const std::vector<double> scaleFactors =
-            generateScaleFactors(dims.row, scale);
     writeCPHD(tempfile.pathname(), numThreads, dims, writeData);
-    const std::vector<cphd::zfloat > readData =
-            checkData(tempfile.pathname(), numThreads, scaleFactors,
-            scale, dims);
+
+    const auto scaleFactors = generateScaleFactors(dims.row, scale);
+    const auto readData = checkData(tempfile.pathname(), numThreads, scaleFactors, scale, dims);
     return compareVectors(readData, writeData, scaleFactors, scale);
 }
 
 TEST_CASE(testUnscaledInt8)
 {
     const types::RowCol<size_t> dims(128, 128);
-    const std::vector<cphd::zint8_t > writeData =
-            generateData<int8_t>(dims.area());
+    const auto writeData = generateData<cphd::zint8_t>(dims.area());
     const bool scale = false;
     TEST_ASSERT(runTest(scale, writeData));
 }
@@ -215,16 +213,14 @@ TEST_CASE(testUnscaledInt8)
 TEST_CASE(testScaledInt8)
 {
     const types::RowCol<size_t> dims(128, 128);
-    const std::vector<cphd::zint8_t > writeData =
-            generateData<int8_t>(dims.area());
+    const auto writeData = generateData<cphd::zint8_t>(dims.area());
     const bool scale = true;
     TEST_ASSERT(runTest(scale, writeData));
 }
 TEST_CASE(testUnscaledInt16)
 {
     const types::RowCol<size_t> dims(128, 128);
-    const std::vector<cphd::zint16_t > writeData =
-            generateData<int16_t>(dims.area());
+    const auto writeData = generateData<cphd::zint16_t>(dims.area());
     const bool scale = false;
     TEST_ASSERT(runTest(scale, writeData));
 }
@@ -232,8 +228,7 @@ TEST_CASE(testUnscaledInt16)
 TEST_CASE(testScaledInt16)
 {
     const types::RowCol<size_t> dims(128, 128);
-    const std::vector<cphd::zint16_t > writeData =
-            generateData<int16_t>(dims.area());
+    const auto writeData = generateData<cphd::zint16_t>(dims.area());
     const bool scale = true;
     TEST_ASSERT(runTest(scale, writeData));
 }
@@ -241,8 +236,7 @@ TEST_CASE(testScaledInt16)
 TEST_CASE(testUnscaledFloat)
 {
     const types::RowCol<size_t> dims(128, 128);
-    const std::vector<cphd::zfloat > writeData =
-            generateData<float>(dims.area());
+    const auto writeData = generateData<cphd::zfloat>(dims.area());
     const bool scale = false;
     TEST_ASSERT(runTest(scale, writeData));
 }
@@ -250,8 +244,7 @@ TEST_CASE(testUnscaledFloat)
 TEST_CASE(testScaledFloat)
 {
     const types::RowCol<size_t> dims(128, 128);
-    const std::vector<cphd::zfloat > writeData =
-            generateData<float>(dims.area());
+    const auto writeData = generateData<cphd::zfloat>(dims.area());
     const bool scale = true;
     TEST_ASSERT(runTest(scale, writeData));
 }
diff --git a/six/modules/c++/samples/round_trip_six.cpp b/six/modules/c++/samples/round_trip_six.cpp
index c28844a37..83e8f28da 100644
--- a/six/modules/c++/samples/round_trip_six.cpp
+++ b/six/modules/c++/samples/round_trip_six.cpp
@@ -96,9 +96,9 @@ struct Buffers final
 // We'll expand to complex<float> starting in the first half of the buffer
 void expandComplex(size_t numPixels, std::byte* buffer)
 {
-    const types::zint16_t* const input =
-            reinterpret_cast<types::zint16_t*>(
-                    buffer + numPixels * sizeof(types::zint16_t));
+    const six::zint16_t* const input =
+            reinterpret_cast<six::zint16_t*>(
+                    buffer + numPixels * sizeof(six::zint16_t));
 
     six::zfloat* const output =
             reinterpret_cast<six::zfloat*>(buffer);
@@ -137,7 +137,7 @@ void compressInteger(size_t numPixels, std::byte* buffer)
     }
 
     auto const input = reinterpret_cast<const six::zfloat*>(buffer);
-    auto const output = reinterpret_cast<types::zint16_t*>(buffer);
+    auto const output = reinterpret_cast<six::zint16_t*>(buffer);
     const float diff = max - min;
 
     // If diff ends up being zero, we will get a division by 0 error.
@@ -145,14 +145,14 @@ void compressInteger(size_t numPixels, std::byte* buffer)
     // fill it with 0s.
     if (diff == 0.0f)
     {
-        std::fill_n(output, numPixels, types::zint16_t(0, 0));
+        std::fill_n(output, numPixels, six::zint16_t(0, 0));
         return;
     }
 
     const CompressFloat compressFloat(min, diff);
     for (size_t ii = 0; ii < numPixels; ++ii)
     {
-        output[ii] = types::zint16_t(
+        output[ii] = six::zint16_t(
                 compressFloat(input[ii].real()),
                 compressFloat(input[ii].imag()));
     }
diff --git a/six/modules/c++/samples/test_dump_images.cpp b/six/modules/c++/samples/test_dump_images.cpp
index 8b279e4b7..918a5ea23 100644
--- a/six/modules/c++/samples/test_dump_images.cpp
+++ b/six/modules/c++/samples/test_dump_images.cpp
@@ -53,7 +53,7 @@ void writeSIOFileHeader(size_t numRows,
         elementType = sio::lite::FileHeader::COMPLEX_FLOAT;
         break;
     case six::PixelType::RE16I_IM16I:
-        elementSize = sizeof(types::zint16_t);
+        elementSize = sizeof(six::zint16_t);
         elementType = sio::lite::FileHeader::COMPLEX_SIGNED;
         break;
     case six::PixelType::MONO8I:
diff --git a/six/modules/c++/six.sicd/tests/TestUtilities.h b/six/modules/c++/six.sicd/tests/TestUtilities.h
index 056ee0ba3..7100bfa61 100644
--- a/six/modules/c++/six.sicd/tests/TestUtilities.h
+++ b/six/modules/c++/six.sicd/tests/TestUtilities.h
@@ -55,14 +55,15 @@ struct GetPixelType<int16_t>
 };
 
 // Create dummy SICD data
-template <typename DataTypeT>
+template <typename CxDataTypeT>
 std::unique_ptr<six::sicd::ComplexData>
 createData(const types::RowCol<size_t>& dims)
 {
     std::unique_ptr<six::sicd::ComplexData> data =
             six::sicd::Utilities::createFakeComplexData();
     setExtent(*data, dims);
-    data->setPixelType(GetPixelType<DataTypeT>::getPixelType());
+    using value_type = typename CxDataTypeT::value_type;
+    data->setPixelType(GetPixelType<value_type>::getPixelType());
     return data;
 }
 
diff --git a/six/modules/c++/six.sicd/tests/test_sicd_byte_provider.cpp b/six/modules/c++/six.sicd/tests/test_sicd_byte_provider.cpp
index 86b94a1e1..29613f573 100644
--- a/six/modules/c++/six.sicd/tests/test_sicd_byte_provider.cpp
+++ b/six/modules/c++/six.sicd/tests/test_sicd_byte_provider.cpp
@@ -39,7 +39,7 @@
 namespace
 {
 // Main test class
-template <typename DataTypeT>
+template <typename CxDataTypeT>
 struct Tester final
 {
     Tester(const std::vector<std::string>& schemaPaths,
@@ -50,7 +50,7 @@ struct Tester final
         mDims(123, 456),
         // Have to release() here to prevent nasty runtime error
         // with Solaris
-        mData(createData<DataTypeT>(mDims).release()),
+        mData(createData<CxDataTypeT>(mDims).release()),
         mImage(mDims.area()),
         mTestPathname("streaming_write.nitf"),
         mSchemaPaths(schemaPaths),
@@ -60,16 +60,17 @@ struct Tester final
     {
         for (size_t ii = 0; ii < mImage.size(); ++ii)
         {
-            mImage[ii] = types::complex<DataTypeT>(
-                    static_cast<DataTypeT>(ii),
-                    static_cast<DataTypeT>(ii * 10));
+            using value_type = typename CxDataTypeT::value_type;
+            mImage[ii] = CxDataTypeT(
+                    static_cast<value_type>(ii),
+                    static_cast<value_type>(ii * 10));
         }
 
         mBigEndianImage = mImage;
         if (sys::isLittleEndianSystem())
         {
             void* const buffer = mBigEndianImage.data();
-            constexpr auto elemSize = sizeof(DataTypeT);
+            constexpr auto elemSize = sizeof(CxDataTypeT);
             const auto numElems = mBigEndianImage.size() * 2; // real and imag
             sys::byteSwap(buffer, elemSize, numElems);
         }
@@ -148,8 +149,8 @@ struct Tester final
 
     const types::RowCol<size_t> mDims;
     std::unique_ptr<six::sicd::ComplexData> mData;
-    std::vector<types::complex<DataTypeT> > mImage;
-    std::vector<types::complex<DataTypeT> > mBigEndianImage;
+    std::vector<CxDataTypeT > mImage;
+    std::vector<CxDataTypeT > mBigEndianImage;
 
     std::unique_ptr<const CompareFiles> mCompareFiles;
     const std::string mTestPathname;
@@ -161,8 +162,8 @@ struct Tester final
     bool mSuccess;
 };
 
-template <typename DataTypeT>
-void Tester<DataTypeT>::normalWrite()
+template <typename CxDataTypeT>
+void Tester<CxDataTypeT>::normalWrite()
 {
     mem::SharedPtr<six::Container> container(
             new six::Container(six::DataType::COMPLEX));
@@ -183,8 +184,8 @@ void Tester<DataTypeT>::normalWrite()
     mCompareFiles.reset(new CompareFiles(mNormalPathname));
 }
 
-template <typename DataTypeT>
-void Tester<DataTypeT>::testSingleWrite()
+template <typename CxDataTypeT>
+void Tester<CxDataTypeT>::testSingleWrite()
 {
     const EnsureFileCleanup ensureFileCleanup(mTestPathname);
 
@@ -206,8 +207,8 @@ void Tester<DataTypeT>::testSingleWrite()
     compare("Single write");
 }
 
-template <typename DataTypeT>
-void Tester<DataTypeT>::testMultipleWrites()
+template <typename CxDataTypeT>
+void Tester<CxDataTypeT>::testMultipleWrites()
 {
     const EnsureFileCleanup ensureFileCleanup(mTestPathname);
 
@@ -291,8 +292,8 @@ void Tester<DataTypeT>::testMultipleWrites()
     compare("Multiple writes");
 }
 
-template <typename DataTypeT>
-void Tester<DataTypeT>::testOneWritePerRow()
+template <typename CxDataTypeT>
+void Tester<CxDataTypeT>::testOneWritePerRow()
 {
     const EnsureFileCleanup ensureFileCleanup(mTestPathname);
 
@@ -323,7 +324,7 @@ void Tester<DataTypeT>::testOneWritePerRow()
     compare("One write per row");
 }
 
-template <typename DataTypeT>
+template <typename CxDataTypeT>
 bool doTests(const std::vector<std::string>& schemaPaths,
              bool setMaxProductSize,
              size_t numRowsPerSeg)
@@ -334,11 +335,11 @@ bool doTests(const std::vector<std::string>& schemaPaths,
     //       It would be better to get the logic fixed that forces
     //       segmentation on the number of rows via OPT_MAX_ILOC_ROWS
     static const size_t APPROX_HEADER_SIZE = 2 * 1024;
-    const size_t numBytesPerRow = 456 * sizeof(types::complex<DataTypeT>);
+    const size_t numBytesPerRow = 456 * sizeof(CxDataTypeT);
     const size_t maxProductSize = numRowsPerSeg * numBytesPerRow +
             APPROX_HEADER_SIZE;
 
-    Tester<DataTypeT> tester(schemaPaths, setMaxProductSize, maxProductSize);
+    Tester<CxDataTypeT> tester(schemaPaths, setMaxProductSize, maxProductSize);
     tester.testSingleWrite();
     tester.testMultipleWrites();
     tester.testOneWritePerRow();
@@ -351,12 +352,12 @@ bool doTestsBothDataTypes(const std::vector<std::string>& schemaPaths,
                           size_t numRowsPerSeg = 0)
 {
     bool success = true;
-    if (!doTests<float>(schemaPaths, setMaxProductSize, numRowsPerSeg))
+    if (!doTests<six::zfloat>(schemaPaths, setMaxProductSize, numRowsPerSeg))
     {
         success = false;
     }
 
-    if (!doTests<int16_t>(schemaPaths, setMaxProductSize, numRowsPerSeg))
+    if (!doTests<six::zint16_t>(schemaPaths, setMaxProductSize, numRowsPerSeg))
     {
         success = false;
     }
diff --git a/six/modules/c++/six.sicd/tests/test_streaming_write.cpp b/six/modules/c++/six.sicd/tests/test_streaming_write.cpp
index 4c6169147..429e32e5d 100644
--- a/six/modules/c++/six.sicd/tests/test_streaming_write.cpp
+++ b/six/modules/c++/six.sicd/tests/test_streaming_write.cpp
@@ -103,13 +103,15 @@ struct GetPixelType<int16_t>
 };
 
 // Create dummy SICD data
-template <typename DataTypeT>
+template <typename CxDataTypeT>
 std::unique_ptr<six::Data>
 createData(const types::RowCol<size_t>& dims)
 {
+    using value_type = typename CxDataTypeT::value_type;
+
     six::sicd::ComplexData* data(new six::sicd::ComplexData());
     std::unique_ptr<six::Data> scopedData(data);
-    data->setPixelType(GetPixelType<DataTypeT>::getPixelType());
+    data->setPixelType(GetPixelType<value_type>::getPixelType());
     setExtent(*data, dims);
     data->setName("corename");
     data->setSource("sensorname");
@@ -215,7 +217,7 @@ void subsetData(const T* orig,
 }
 
 // Main test class
-template <typename DataTypeT>
+template <typename CxDataTypeT>
 struct Tester final
 {
     Tester(const std::vector<std::string>& schemaPaths,
@@ -233,11 +235,13 @@ struct Tester final
         mMaxProductSize(maxProductSize),
         mSuccess(true)
     {
+        using value_type = typename CxDataTypeT::value_type;
+
         for (size_t ii = 0; ii < mImage.size(); ++ii)
         {
-            mImage[ii] = types::complex<DataTypeT>(
-                    static_cast<DataTypeT>(ii),
-                    static_cast<DataTypeT>(ii * 10));
+            mImage[ii] = CxDataTypeT(
+                    static_cast<value_type>(ii),
+                    static_cast<value_type>(ii * 10));
         }
 
         normalWrite();
@@ -291,8 +295,8 @@ struct Tester final
 
     mem::SharedPtr<six::Container> mContainer;
     const types::RowCol<size_t> mDims;
-    std::vector<types::complex<DataTypeT> > mImage;
-    types::complex<DataTypeT>* const mImagePtr;
+    std::vector<CxDataTypeT > mImage;
+    CxDataTypeT* const mImagePtr;
 
     std::unique_ptr<const CompareFiles> mCompareFiles;
     const std::string mTestPathname;
@@ -388,8 +392,8 @@ void Tester<DataTypeT>::testMultipleWritesOfFullRows()
     compare("Multiple writes of full rows");
 }
 
-template <typename DataTypeT>
-void Tester<DataTypeT>::testMultipleWritesOfPartialRows()
+template <typename CxDataTypeT>
+void Tester<CxDataTypeT>::testMultipleWritesOfPartialRows()
 {
     const EnsureFileCleanup ensureFileCleanup(mTestPathname);
 
@@ -402,7 +406,7 @@ void Tester<DataTypeT>::testMultipleWritesOfPartialRows()
     // Rows [40, 60)
     // Cols [400, 456)
     types::RowCol<size_t> offset(40, 400);
-    std::vector<types::complex<DataTypeT> > subset;
+    std::vector<CxDataTypeT > subset;
     types::RowCol<size_t> subsetDims(20, 56);
     subsetData(mImagePtr, mDims.col, offset, subsetDims, subset);
     sicdWriter.save(subset.data(), offset, subsetDims);
@@ -446,7 +450,7 @@ void Tester<DataTypeT>::testMultipleWritesOfPartialRows()
     compare("Multiple writes of partial rows");
 }
 
-template <typename DataTypeT>
+template <typename CxDataTypeT>
 bool doTests(const std::vector<std::string>& schemaPaths,
              bool setMaxProductSize,
              size_t numRowsPerSeg)
@@ -457,11 +461,11 @@ bool doTests(const std::vector<std::string>& schemaPaths,
     //       It would be better to get the logic fixed that forces
     //       segmentation on the number of rows via OPT_MAX_ILOC_ROWS
     static const size_t APPROX_HEADER_SIZE = 2 * 1024;
-    const size_t numBytesPerRow = 456 * sizeof(types::complex<DataTypeT>);
+    const size_t numBytesPerRow = 456 * sizeof(CxDataTypeT);
     const size_t maxProductSize = numRowsPerSeg * numBytesPerRow +
             APPROX_HEADER_SIZE;
 
-    Tester<DataTypeT> tester(schemaPaths, setMaxProductSize, maxProductSize);
+    Tester<CxDataTypeT> tester(schemaPaths, setMaxProductSize, maxProductSize);
     tester.testSingleWrite();
     tester.testMultipleWritesOfFullRows();
     tester.testMultipleWritesOfPartialRows();
@@ -474,12 +478,12 @@ bool doTestsBothDataTypes(const std::vector<std::string>& schemaPaths,
                           size_t numRowsPerSeg = 0)
 {
     bool success = true;
-    if (!doTests<float>(schemaPaths, setMaxProductSize, numRowsPerSeg))
+    if (!doTests<six::zfloat>(schemaPaths, setMaxProductSize, numRowsPerSeg))
     {
         success = false;
     }
 
-    if (!doTests<int16_t>(schemaPaths, setMaxProductSize, numRowsPerSeg))
+    if (!doTests<six::zint16_t>(schemaPaths, setMaxProductSize, numRowsPerSeg))
     {
         success = false;
     }
diff --git a/six/modules/c++/six.sicd/unittests/test_CollectionInfo.cpp b/six/modules/c++/six.sicd/unittests/test_CollectionInfo.cpp
index 9c33121b5..b05e580d1 100644
--- a/six/modules/c++/six.sicd/unittests/test_CollectionInfo.cpp
+++ b/six/modules/c++/six.sicd/unittests/test_CollectionInfo.cpp
@@ -49,7 +49,7 @@
 
 TEST_CASE(DummyData)
 {
-    const auto data = createData<float>(types::RowCol<size_t>(10, 10));
+    const auto data = createData<six::zfloat>(types::RowCol<size_t>(10, 10));
 
     const std::vector<std::string> schemaPaths;
     const auto result = six::sicd::Utilities::toXMLString(*data, schemaPaths);
@@ -69,7 +69,7 @@ TEST_CASE(Classification)
 {
     const std::string classificationText("UNCLASSIFIED");
 
-    auto data = createData<float>(types::RowCol<size_t>(10, 10));
+    auto data = createData<six::zfloat>(types::RowCol<size_t>(10, 10));
     data->collectionInformation->setClassificationLevel(classificationText);
     TEST_ASSERT_TRUE(data->getClassification().isUnclassified());
 
@@ -98,7 +98,7 @@ TEST_CASE(ClassificationCanada)
     const std::string classificationText("NON CLASSIFI\xc3\x89 / UNCLASSIFIED"); // UTF-8 "NON CLASSIFIÉ / UNCLASSIFIED"
 #endif
 
-    auto data = createData<float>(types::RowCol<size_t>(10, 10));
+    auto data = createData<six::zfloat>(types::RowCol<size_t>(10, 10));
     data->collectionInformation->setClassificationLevel(classificationText);
     TEST_ASSERT_TRUE(data->getClassification().isUnclassified());
 
diff --git a/six/modules/c++/six/include/six/Adapters.h b/six/modules/c++/six/include/six/Adapters.h
index 2d359c121..84fe1b6a3 100644
--- a/six/modules/c++/six/include/six/Adapters.h
+++ b/six/modules/c++/six/include/six/Adapters.h
@@ -170,7 +170,7 @@ class NewMemoryWriteHandler final : public nitf::WriteHandler // all of our code
 			  std::span<const six::zfloat> buffer,
 			  size_t firstRow, const Data& data, bool doByteSwap);
     NewMemoryWriteHandler(const NITFSegmentInfo& info,
-			  std::span<const types::zint16_t> buffer,
+			  std::span<const six::zint16_t> buffer,
 			  size_t firstRow, const Data& data, bool doByteSwap);
     NewMemoryWriteHandler(const NITFSegmentInfo& info,
 			  std::span<const std::pair<uint8_t, uint8_t>> buffer,
diff --git a/six/modules/c++/six/include/six/AmplitudeTable.h b/six/modules/c++/six/include/six/AmplitudeTable.h
index 5ea0e750f..649c39fab 100644
--- a/six/modules/c++/six/include/six/AmplitudeTable.h
+++ b/six/modules/c++/six/include/six/AmplitudeTable.h
@@ -197,8 +197,8 @@ class ComplexToAMP8IPHS8I final
     ~ComplexToAMP8IPHS8I() = default;
     ComplexToAMP8IPHS8I(const ComplexToAMP8IPHS8I&) = delete;
     ComplexToAMP8IPHS8I& operator=(const ComplexToAMP8IPHS8I&) = delete;
-    ComplexToAMP8IPHS8I(ComplexToAMP8IPHS8I&&) = default;
-    ComplexToAMP8IPHS8I& operator=(ComplexToAMP8IPHS8I&&) = default;
+    ComplexToAMP8IPHS8I(ComplexToAMP8IPHS8I&&) = delete; // implicitly deleted because of =delete for copy
+    ComplexToAMP8IPHS8I& operator=(ComplexToAMP8IPHS8I&&) = delete; // implicitly deleted because of =delete for copy
 
     /*!
      * Get the nearest amplitude and phase value given a complex value
diff --git a/six/modules/c++/six/include/six/NITFWriteControl.h b/six/modules/c++/six/include/six/NITFWriteControl.h
index a4a0e6f14..499e49da6 100644
--- a/six/modules/c++/six/include/six/NITFWriteControl.h
+++ b/six/modules/c++/six/include/six/NITFWriteControl.h
@@ -300,7 +300,7 @@ class NITFWriteControl : public WriteControl
 
     // Be explicit about the types of images that can be saved; templates are provided below.
     void save_image(std::span<const six::zfloat>, nitf::IOInterface&, const std::vector<std::filesystem::path>&);
-    void save_image(std::span<const types::zint16_t>, nitf::IOInterface&, const std::vector<std::filesystem::path>&);
+    void save_image(std::span<const six::zint16_t>, nitf::IOInterface&, const std::vector<std::filesystem::path>&);
     void save_image(std::span<const std::pair<uint8_t, uint8_t>>, nitf::IOInterface&, const std::vector<std::filesystem::path>&);
     void save_image(std::span<const uint8_t>, nitf::IOInterface&, const std::vector<std::filesystem::path>&);
     void save_image(std::span<const uint16_t>, nitf::IOInterface&, const std::vector<std::filesystem::path>&);
diff --git a/six/modules/c++/six/include/six/Parameter.h b/six/modules/c++/six/include/six/Parameter.h
index 1f001529a..5db4b9e8e 100644
--- a/six/modules/c++/six/include/six/Parameter.h
+++ b/six/modules/c++/six/include/six/Parameter.h
@@ -19,8 +19,9 @@
  * see <http://www.gnu.org/licenses/>.
  *
  */
-#ifndef __SIX_PARAMETER_H__
-#define __SIX_PARAMETER_H__
+#pragma once
+#ifndef SIX_six_Parameter_h_INCLUDED_
+#define SIX_six_Parameter_h_INCLUDED_
 
 #include <types/complex.h>
 #include <import/str.h>
@@ -38,33 +39,38 @@ namespace six
  *  and get parameters directly from native types without string
  *  conversion.
  */
-class Parameter
+struct Parameter final
 {
-public:
     Parameter() = default;
-    //!  Destructor
-    ~Parameter()
-    {
-    }
+    ~Parameter() = default;
 
-    Parameter(const Parameter & other)
-      : mValue(other.mValue),
-        mName(other.mName)
-    {
-    }
+    Parameter(const Parameter&) = default;
+    Parameter& operator=(const Parameter&) = default;
+    Parameter(Parameter&&) = default;
+    Parameter& operator=(Parameter&&) = default;
 
     //!  Templated constructor, constructs from given value
     template<typename T>
-    Parameter(T value)
+    Parameter(const T& value)
     {
         mValue = str::toString<T>(value);
     }
+    Parameter(const char* value) : Parameter(std::string(value))
+    {
+    }
 
     template<typename T>
-    Parameter(types::complex<T> value)
+    Parameter(const std::complex<T>& value)
     {
-        mValue = str::toString<types::complex<T> >(mValue);
+        mValue = str::toString<std::complex<T> >(mValue);
     }
+    //#if CODA_OSS_types_unique_zinteger
+    //template<typename T>
+    //Parameter(const types::zinteger<T>& value)
+    //{
+    //    mValue = str::toString<types::zinteger<T> >(mValue);
+    //}
+    //#endif
 
      /*!
      * \tparam T Desired (presumably numeric) type to convert to
@@ -72,28 +78,40 @@ class Parameter
      * \return Value as a T type
      */
     template<typename T>
-    inline operator T() const
+    operator T() const
     {
         return str::toType<T>(mValue);
     }
 
     //!  Get a string as a string
-    inline std::string str() const
+    std::string str() const
     {
         return mValue;
     }
     //!  Get the parameter's name
-    inline std::string getName() const
+    std::string getName() const
     {
         return mName;
     }
 
     //! Get complex parameter
     template<typename T>
-    inline types::complex<T> getComplex() const
+    std::complex<T> getComplex() const
     {
-        return str::toType<types::complex<T> >(mValue);
+        return str::toType<std::complex<T> >(mValue);
     }
+    template<typename T>
+    void getComplex(std::complex<T>& result) const
+    {
+        result = str::toType<std::complex<T> >(mValue);
+    }
+    //#if CODA_OSS_types_unique_zinteger
+    //template<typename T>
+    //void getComplex(types::zinteger<T>& result) const
+    //{
+    //    result = str::toType<types::zinteger<T> >(mValue);
+    //}
+    //#endif
 
     //!  Set the parameters' name
     void setName(std::string name)
@@ -103,17 +121,28 @@ class Parameter
 
     //!  Set the parameters' value
     template<typename T>
-    void setValue(T value)
+    void setValue(const T& value)
     {
         mValue = str::toString<T>(value);
     }
+    void setValue(const char* value)
+    {
+        setValue(std::string(value));
+    }
 
     //! Overload templated setValue function
     template<typename T>
-    void setValue(const types::complex<T>& value)
+    void setValue(const std::complex<T>& value)
     {
-        mValue = str::toString<types::complex<T> >(value);
+        mValue = str::toString<std::complex<T> >(value);
     }
+    //#if CODA_OSS_types_unique_zinteger 
+    //template<typename T>
+    //void setValue(const types::zinteger<T>& value)
+    //{
+    //    mValue = str::toString<types::zinteger<T> >(value);
+    //}
+    //#endif
 
     //!  Get back const char*
     operator const char*() const
@@ -121,23 +150,20 @@ class Parameter
         return mValue.c_str();
     }
 
-    bool operator==(const Parameter& o) const
-    {
-        return mName == o.mName && mValue == o.mValue;
-    }
-
-    bool operator!=(const Parameter& o) const
-    {
-        return !((*this) == o);
-    }
-
-protected:
+private:
     std::string mValue;
     std::string mName;
-
 };
 
+inline bool operator==(const Parameter& lhs, const Parameter& rhs)
+{
+    return (lhs.getName() == rhs.getName()) && (lhs.str() == rhs.str());
+}
+inline bool operator!=(const Parameter& lhs, const Parameter& rhs)
+{
+    return !(lhs == rhs);
 }
 
-#endif
+}
 
+#endif // SIX_six_Parameter_h_INCLUDED_
\ No newline at end of file
diff --git a/six/modules/c++/six/include/six/Types.h b/six/modules/c++/six/include/six/Types.h
index c2c673602..961ec5895 100644
--- a/six/modules/c++/six/include/six/Types.h
+++ b/six/modules/c++/six/include/six/Types.h
@@ -52,6 +52,7 @@ namespace six
 {
     using zfloat = scene::zfloat;
     using zdouble = scene::zdouble;
+    using zint16_t = std::complex<int16_t>; // TODO: types::zint16_t;
 }
 #include "six/AmplitudeTable.h"
 
@@ -198,7 +199,7 @@ struct Constants
             // Each pixel is stored as a pair of numbers that represent the real and imaginary 
             // components. Each component is stored in a 16-bit signed integer in 2's 
             // complement format (2 bytes per component, 4 bytes per pixel). 
-            static_assert(sizeof(types::zint16_t) == 4, "RE16I_IM16I should be two 16-bit integers");
+            static_assert(sizeof(six::zint16_t) == 4, "RE16I_IM16I should be two 16-bit integers");
             return 4;
         }
 
diff --git a/six/modules/c++/six/source/Adapters.cpp b/six/modules/c++/six/source/Adapters.cpp
index 790809dee..f1693a494 100644
--- a/six/modules/c++/six/source/Adapters.cpp
+++ b/six/modules/c++/six/source/Adapters.cpp
@@ -294,7 +294,7 @@ NewMemoryWriteHandler::NewMemoryWriteHandler(const NITFSegmentInfo& info,
 }
 
 NewMemoryWriteHandler::NewMemoryWriteHandler(const NITFSegmentInfo& info,
-    std::span<const types::zint16_t> buffer, size_t firstRow, const Data& data, bool doByteSwap)
+    std::span<const six::zint16_t> buffer, size_t firstRow, const Data& data, bool doByteSwap)
     : NewMemoryWriteHandler(info, cast(buffer), firstRow, data, doByteSwap)
 {
     // Each pixel is stored as a pair of numbers that represent the real and imaginary 
diff --git a/six/modules/c++/six/source/NITFWriteControl.cpp b/six/modules/c++/six/source/NITFWriteControl.cpp
index d96406281..06dd4e73f 100644
--- a/six/modules/c++/six/source/NITFWriteControl.cpp
+++ b/six/modules/c++/six/source/NITFWriteControl.cpp
@@ -524,7 +524,7 @@ void NITFWriteControl::save_image(std::span<const six::zfloat> imageData,
 {
     do_save(imageData, outputFile, convert_paths(schemaPaths));
 }
-void NITFWriteControl::save_image(std::span<const types::zint16_t> imageData,
+void NITFWriteControl::save_image(std::span<const six::zint16_t> imageData,
     nitf::IOInterface& outputFile,
     const std::vector<std::filesystem::path>& schemaPaths)
 {
diff --git a/six/modules/c++/six/source/SICommonXMLParser.cpp b/six/modules/c++/six/source/SICommonXMLParser.cpp
index 93ef38b68..6b9da165b 100644
--- a/six/modules/c++/six/source/SICommonXMLParser.cpp
+++ b/six/modules/c++/six/source/SICommonXMLParser.cpp
@@ -542,7 +542,7 @@ XMLElem SICommonXMLParser::createLatLonAlt(const std::string& name,
 void SICommonXMLParser::parseParameter(const xml::lite::Element* element, Parameter& p) const
 {
     p.setName(element->getAttributes().getValue("name"));
-    p.setValue<std::string>(element->getCharacterData());
+    p.setValue(element->getCharacterData());
 }
 
 void SICommonXMLParser::parseParameters(const xml::lite::Element* paramXML,