diff --git a/include/aws/crt/TypeTraits.h b/include/aws/crt/TypeTraits.h
index 72ed9d9a6..ffc0c192f 100644
--- a/include/aws/crt/TypeTraits.h
+++ b/include/aws/crt/TypeTraits.h
@@ -26,5 +26,19 @@ namespace Aws
         struct IsSpecializationOf<Primary<Args...>, Primary> : std::true_type
         {
         };
+
+        /**
+         * Forms the logical conjunction of the type traits Args..., effectively performing a logical AND on the
+         * sequence of traits.
+         */
+        template <typename... Args> struct Conjunction : std::true_type
+        {
+        };
+
+        template <typename Arg, typename... Args>
+        struct Conjunction<Arg, Args...> : std::conditional<Arg::value, Conjunction<Args...>, std::false_type>::type
+        {
+        };
+
     } // namespace Crt
 } // namespace Aws
diff --git a/include/aws/crt/Variant.h b/include/aws/crt/Variant.h
index 1ac603fb8..0a7fd6db6 100644
--- a/include/aws/crt/Variant.h
+++ b/include/aws/crt/Variant.h
@@ -5,6 +5,7 @@
  */
 
 #include <aws/common/assert.h>
+#include <aws/crt/TypeTraits.h>
 #include <aws/crt/Utility.h>
 
 #include <algorithm>
@@ -17,6 +18,7 @@ namespace Aws
     {
         namespace VariantDetail
         {
+            // TODO Pass values instead of refs.
             template <typename T> constexpr const T &ConstExprMax(const T &a, const T &b)
             {
                 return (a < b) ? b : a;
@@ -79,7 +81,7 @@ namespace Aws
                     return std::is_same<T, First>::value || ContainsType<T, Second, Rest...>();
                 }
 
-                // a case when the template parameter pack is empty (i.e. Variant<>)
+                // a case when the template parameter pack is empty (i.e. VariantImpl<>)
                 template <typename T> constexpr bool ContainsType()
                 {
                     return false;
@@ -116,477 +118,681 @@ namespace Aws
                 };
             } // namespace VariantDebug
 #endif /* defined(AWS_CRT_ENABLE_VARIANT_DEBUG) */
-        } // namespace VariantDetail
-
-        template <std::size_t Index, typename... Ts> class VariantAlternative;
-
-        /**
-         * Custom implementation of a Variant type. std::variant requires C++17
-         * @tparam Ts types of the variant value
-         */
-        template <typename... Ts> class Variant
-        {
-          private:
-            template <std::size_t Index> using ThisVariantAlternative = VariantAlternative<Index, Ts...>;
 
-            template <typename OtherT>
-            using EnableIfOtherIsThisVariantAlternative = typename std::
-                enable_if<VariantDetail::Checker::HasType<typename std::decay<OtherT>::type, Ts...>::value, int>::type;
+            /* Depending on the Variant types, this struct either deletes special move members or defaults them. */
+            template <bool> class MovableVariant;
 
-          public:
-            using IndexT = VariantDetail::Index::VariantIndex;
-            static constexpr std::size_t AlternativeCount = sizeof...(Ts);
-
-            Variant()
+            template <> class MovableVariant<true>
             {
-                using FirstAlternative = typename ThisVariantAlternative<0>::type;
-                new (m_storage) FirstAlternative();
-                m_index = 0;
-            }
-
-            Variant(const Variant &other)
+              public:
+                MovableVariant() = default;
+                MovableVariant(const MovableVariant &) = default;
+                MovableVariant &operator=(const MovableVariant &) = default;
+                MovableVariant(MovableVariant &&other) = default;
+                MovableVariant &operator=(MovableVariant &&other) = default;
+            };
+            template <> class MovableVariant<false>
             {
-                AWS_FATAL_ASSERT(other.m_index != -1);
-                m_index = other.m_index;
-                VisitorUtil<0, Ts...>::VisitBinary(this, other, CopyMoveConstructor());
-            }
+              public:
+                MovableVariant() = default;
+                MovableVariant(const MovableVariant &) = default;
+                MovableVariant &operator=(const MovableVariant &) = default;
+                MovableVariant(MovableVariant &&) = delete;
+                MovableVariant &operator=(MovableVariant &&) = delete;
+            };
 
-            Variant(Variant &&other)
-            {
-                AWS_FATAL_ASSERT(other.m_index != -1);
-                m_index = other.m_index;
-                VisitorUtil<0, Ts...>::VisitBinary(this, std::move(other), CopyMoveConstructor());
-            }
+            /* Depending on the Variant types, this struct either deletes special copy members or defaults them. */
+            template <bool> class CopyableVariant;
 
-            template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1> Variant(const T &val)
+            template <> class CopyableVariant<true>
             {
-                static_assert(
-                    VariantDetail::Checker::HasType<typename std::decay<T>::type, Ts...>::value,
-                    "This variant does not have such alternative T.");
-                static_assert(
-                    sizeof(T) <= STORAGE_SIZE,
-                    "Attempting to instantiate a Variant with a type bigger than all alternatives.");
-
-                using PlainT = typename std::decay<T>::type;
-                new (m_storage) PlainT(val);
-                m_index = VariantDetail::Index::GetIndexOf<PlainT, Ts...>();
-                AWS_ASSERT(m_index != -1);
-            }
+              public:
+                CopyableVariant() = default;
+                CopyableVariant(const CopyableVariant &other) = default;
+                CopyableVariant &operator=(const CopyableVariant &other) = default;
+                CopyableVariant(CopyableVariant &&) = default;
+                CopyableVariant &operator=(CopyableVariant &&) = default;
+            };
 
-            template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1> Variant(T &&val)
+            template <> class CopyableVariant<false>
             {
-                static_assert(
-                    VariantDetail::Checker::HasType<typename std::decay<T>::type, Ts...>::value,
-                    "This variant does not have such alternative T.");
-                static_assert(
-                    sizeof(T) <= STORAGE_SIZE,
-                    "Attempting to instantiate a Variant with a type bigger than all alternatives.");
-
-                using PlainT = typename std::decay<T>::type;
-                new (m_storage) PlainT(std::forward<T>(val));
-                m_index = VariantDetail::Index::GetIndexOf<PlainT, Ts...>();
-                AWS_ASSERT(m_index != -1);
-            }
+              public:
+                CopyableVariant() = default;
 
-            // An overload to initialize with an Alternative T in-place
-            template <typename T, typename... Args> explicit Variant(Aws::Crt::InPlaceTypeT<T>, Args &&...args)
-            {
-                static_assert(
-                    VariantDetail::Checker::HasType<typename std::decay<T>::type, Ts...>::value,
-                    "This variant does not have such alternative T.");
-                static_assert(
-                    sizeof(T) <= STORAGE_SIZE,
-                    "Attempting to instantiate a Variant with a type bigger than all alternatives.");
-
-                using PlainT = typename std::decay<T>::type;
-                new (m_storage) PlainT(std::forward<Args>(args)...);
-                m_index = VariantDetail::Index::GetIndexOf<PlainT, Ts...>();
-                AWS_ASSERT(m_index != -1);
-            }
+                CopyableVariant(const CopyableVariant &) = delete;
+                CopyableVariant &operator=(const CopyableVariant &) = delete;
 
-            Variant &operator=(const Variant &other)
-            {
-                if (this != &other)
-                {
-                    AWS_FATAL_ASSERT(other.m_index != -1);
-                    if (m_index != other.m_index)
-                    {
-                        Destroy();
-                        m_index = other.m_index;
-                        VisitorUtil<0, Ts...>::VisitBinary(this, other, CopyMoveConstructor());
-                    }
-                    else
-                    {
-                        VisitorUtil<0, Ts...>::VisitBinary(this, other, CopyMoveAssigner());
-                    }
-                }
-                return *this;
-            }
+                CopyableVariant(CopyableVariant &&) = default;
+                CopyableVariant &operator=(CopyableVariant &&) = default;
+            };
 
-            Variant &operator=(Variant &&other)
-            {
-                if (this != &other)
-                {
-                    AWS_FATAL_ASSERT(other.m_index != -1);
-                    if (m_index != other.m_index)
-                    {
-                        Destroy();
-                        m_index = other.m_index;
-                        VisitorUtil<0, Ts...>::VisitBinary(this, std::move(other), CopyMoveConstructor());
-                    }
-                    else
-                    {
-                        VisitorUtil<0, Ts...>::VisitBinary(this, std::move(other), CopyMoveAssigner());
-                    };
-                }
-                return *this;
-            }
+            template <std::size_t Index, typename... Ts> class VariantAlternative;
 
-            /* emplace */
-            template <typename T, typename... Args, EnableIfOtherIsThisVariantAlternative<T> = 1>
-            T &emplace(Args &&...args)
+            template <typename... Ts> class VariantImpl
             {
-                static_assert(
-                    VariantDetail::Checker::HasType<typename std::decay<T>::type, Ts...>::value,
-                    "This variant does not have such alternative T.");
-                static_assert(
-                    sizeof(T) <= STORAGE_SIZE,
-                    "Attempting to instantiate a Variant with a type bigger than all alternatives.");
-
-                Destroy();
-
-                using PlainT = typename std::decay<T>::type;
-                new (m_storage) PlainT(std::forward<Args>(args)...);
-                m_index = VariantDetail::Index::GetIndexOf<PlainT, Ts...>();
-                AWS_ASSERT(m_index != -1);
-
-                T *value = reinterpret_cast<T *>(m_storage);
-                return *value;
-            }
+              private:
+                template <std::size_t Index> using ThisVariantAlternative = VariantAlternative<Index, Ts...>;
 
-            template <std::size_t Index, typename... Args>
-            auto emplace(Args &&...args) -> typename ThisVariantAlternative<Index>::type &
-            {
-                static_assert(Index < AlternativeCount, "Unknown alternative index to emplace");
-                using AlternativeT = typename ThisVariantAlternative<Index>::type;
+                template <typename OtherT>
+                using EnableIfOtherIsThisVariantAlternative = typename std::enable_if<
+                    VariantDetail::Checker::HasType<typename std::decay<OtherT>::type, Ts...>::value,
+                    int>::type;
 
-                return emplace<AlternativeT, Args...>(std::forward<Args>(args)...);
-            }
+              public:
+                using FirstAlternative = typename ThisVariantAlternative<0>::type;
 
-            template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1> bool holds_alternative() const
-            {
-                AWS_ASSERT(m_index != -1);
-                return m_index == VariantDetail::Index::GetIndexOf<T, Ts...>();
-            }
+                static constexpr bool isFirstAlternativeNothrowDefaultConstructible =
+                    std::is_nothrow_default_constructible<FirstAlternative>::value;
 
-            /* non-const get */
-            template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1> T &get()
-            {
-                AWS_FATAL_ASSERT(holds_alternative<T>());
-                T *value = reinterpret_cast<T *>(m_storage);
-                return *value;
-            }
+                static constexpr bool isFirstAlternativeDefaultConstructible =
+                    std::is_nothrow_constructible<FirstAlternative>::value;
 
-            template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1> T *get_if()
-            {
-                if (holds_alternative<T>())
-                {
-                    T *value = reinterpret_cast<T *>(m_storage);
-                    return value;
-                }
-                else
+                using IndexT = VariantDetail::Index::VariantIndex;
+                static constexpr std::size_t AlternativeCount = sizeof...(Ts);
+
+                VariantImpl() noexcept(isFirstAlternativeNothrowDefaultConstructible)
                 {
-                    return nullptr;
+                    new (m_storage) FirstAlternative();
+                    m_index = 0;
                 }
-            }
 
-            template <std::size_t Index> auto get() -> typename ThisVariantAlternative<Index>::type &
-            {
-                static_assert(Index < AlternativeCount, "Unknown alternative index to get");
-                AWS_FATAL_ASSERT(holds_alternative<Index>());
-                using AlternativeT = typename ThisVariantAlternative<Index>::type;
-                AlternativeT *ret = reinterpret_cast<AlternativeT *>(m_storage);
-                return *ret;
-            }
-
-            /* const get */
-            template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1> const T &get() const
-            {
-                AWS_FATAL_ASSERT(holds_alternative<T>());
-                const T *value = reinterpret_cast<const T *>(m_storage);
-                return *value;
-            }
-
-            template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1> const T *get_if() const
-            {
-                if (holds_alternative<T>())
+                VariantImpl(const VariantImpl &other)
                 {
-                    T *value = reinterpret_cast<T *>(m_storage);
-                    return value;
+                    AWS_FATAL_ASSERT(other.m_index != -1);
+                    m_index = other.m_index;
+                    VisitorUtil<0, Ts...>::VisitBinary(this, other, CopyMoveConstructor());
                 }
-                else
+
+                VariantImpl(VariantImpl &&other)
                 {
-                    return nullptr;
+                    AWS_FATAL_ASSERT(other.m_index != -1);
+                    m_index = other.m_index;
+                    VisitorUtil<0, Ts...>::VisitBinary(this, std::move(other), CopyMoveConstructor());
                 }
-            }
-
-            template <std::size_t Index> auto get() const -> const typename ThisVariantAlternative<Index>::type &
-            {
-                static_assert(Index < AlternativeCount, "Unknown alternative index to get");
-                AWS_ASSERT(Index == m_index);
-                using AlternativeT = typename ThisVariantAlternative<Index>::type;
-                const AlternativeT *ret = reinterpret_cast<const AlternativeT *>(m_storage);
-                return *ret;
-            }
 
-            /* This is just a templated way to say
-             * "int*" for
-             * a VariantAlternative<0, Variant<int, char, long>()>*/
-            template <std::size_t Index>
-            using RawAlternativePointerT =
-                typename std::add_pointer<typename ThisVariantAlternative<Index>::type>::type;
+                template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1>
+                VariantImpl(const T &val) noexcept(
+                    std::is_nothrow_constructible<typename std::decay<T>::type, decltype(val)>::value)
+                {
+                    static_assert(
+                        VariantDetail::Checker::HasType<typename std::decay<T>::type, Ts...>::value,
+                        "This variant does not have such alternative T.");
+                    static_assert(
+                        sizeof(T) <= STORAGE_SIZE,
+                        "Attempting to instantiate a Variant with a type bigger than all alternatives.");
+
+                    using PlainT = typename std::decay<T>::type;
+                    new (m_storage) PlainT(val);
+                    m_index = VariantDetail::Index::GetIndexOf<PlainT, Ts...>();
+                    AWS_ASSERT(m_index != -1);
+                }
 
-            template <std::size_t Index> auto get_if() -> RawAlternativePointerT<Index>
-            {
-                static_assert(Index < AlternativeCount, "Unknown alternative index to get");
-                if (holds_alternative<Index>())
-                {
-                    using AlternativePtrT = RawAlternativePointerT<Index>;
-                    AlternativePtrT value = reinterpret_cast<AlternativePtrT>(m_storage);
-                    return value;
+                template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1>
+                VariantImpl(T &&val) noexcept(
+                    std::is_nothrow_constructible<typename std::decay<T>::type, decltype(val)>::value)
+                {
+                    static_assert(
+                        VariantDetail::Checker::HasType<typename std::decay<T>::type, Ts...>::value,
+                        "This variant does not have such alternative T.");
+                    static_assert(
+                        sizeof(T) <= STORAGE_SIZE,
+                        "Attempting to instantiate a Variant with a type bigger than all alternatives.");
+
+                    using PlainT = typename std::decay<T>::type;
+                    new (m_storage) PlainT(std::forward<T>(val));
+                    m_index = VariantDetail::Index::GetIndexOf<PlainT, Ts...>();
+                    AWS_ASSERT(m_index != -1);
                 }
-                else
+
+                // An overload to initialize with an Alternative T in-place
+                template <typename T, typename... Args> explicit VariantImpl(Aws::Crt::InPlaceTypeT<T>, Args &&...args)
                 {
-                    return nullptr;
-                }
-            }
+                    static_assert(
+                        VariantDetail::Checker::HasType<typename std::decay<T>::type, Ts...>::value,
+                        "This variant does not have such alternative T.");
+                    static_assert(
+                        sizeof(T) <= STORAGE_SIZE,
+                        "Attempting to instantiate a Variant with a type bigger than all alternatives.");
 
-            template <std::size_t Index>
-            using ConstRawAlternativePointerT = typename std::add_pointer<
-                typename std::add_const<typename ThisVariantAlternative<Index>::type>::type>::type;
+                    using PlainT = typename std::decay<T>::type;
+                    new (m_storage) PlainT(std::forward<Args>(args)...);
+                    m_index = VariantDetail::Index::GetIndexOf<PlainT, Ts...>();
+                    AWS_ASSERT(m_index != -1);
+                }
 
-            template <std::size_t Index> auto get_if() const -> ConstRawAlternativePointerT<Index>
-            {
-                static_assert(Index < AlternativeCount, "Unknown alternative index to get");
-                if (holds_alternative<Index>())
+                VariantImpl &operator=(const VariantImpl &other)
                 {
-                    using AlternativePtrT = ConstRawAlternativePointerT<Index>;
-                    AlternativePtrT value = reinterpret_cast<AlternativePtrT>(m_storage);
-                    return value;
+                    if (this != &other)
+                    {
+                        AWS_FATAL_ASSERT(other.m_index != -1);
+                        if (m_index != other.m_index)
+                        {
+                            Destroy();
+                            m_index = other.m_index;
+                            VisitorUtil<0, Ts...>::VisitBinary(this, other, CopyMoveConstructor());
+                        }
+                        else
+                        {
+                            VisitorUtil<0, Ts...>::VisitBinary(this, other, CopyMoveAssigner());
+                        }
+                    }
+                    return *this;
                 }
-                else
+
+                VariantImpl &operator=(VariantImpl &&other)
                 {
-                    return nullptr;
+                    if (this != &other)
+                    {
+                        AWS_FATAL_ASSERT(other.m_index != -1);
+                        if (m_index != other.m_index)
+                        {
+                            Destroy();
+                            m_index = other.m_index;
+                            VisitorUtil<0, Ts...>::VisitBinary(this, std::move(other), CopyMoveConstructor());
+                        }
+                        else
+                        {
+                            VisitorUtil<0, Ts...>::VisitBinary(this, std::move(other), CopyMoveAssigner());
+                        };
+                    }
+                    return *this;
                 }
-            }
 
-            std::size_t index() const { return m_index; }
+                /* emplace */
+                template <typename T, typename... Args, EnableIfOtherIsThisVariantAlternative<T> = 1>
+                T &emplace(Args &&...args)
+                {
+                    static_assert(
+                        VariantDetail::Checker::HasType<typename std::decay<T>::type, Ts...>::value,
+                        "This variant does not have such alternative T.");
+                    static_assert(
+                        sizeof(T) <= STORAGE_SIZE,
+                        "Attempting to instantiate a Variant with a type bigger than all alternatives.");
 
-            ~Variant() { Destroy(); }
+                    Destroy();
 
-            template <typename VisitorT> void Visit(VisitorT &&visitor)
-            {
-                return VisitorUtil<0, Ts...>::Visit(this, std::forward<VisitorT>(visitor));
-            }
+                    using PlainT = typename std::decay<T>::type;
+                    new (m_storage) PlainT(std::forward<Args>(args)...);
+                    m_index = VariantDetail::Index::GetIndexOf<PlainT, Ts...>();
+                    AWS_ASSERT(m_index != -1);
 
-          private:
-            static constexpr std::size_t STORAGE_SIZE = VariantDetail::ParameterPackSize::GetMaxSizeOf<Ts...>();
+                    T *value = reinterpret_cast<T *>(m_storage);
+                    return *value;
+                }
 
-            alignas(VariantDetail::ParameterPackSize::AlignAsPack<Ts...>()) char m_storage[STORAGE_SIZE];
-            IndexT m_index = -1;
-#if defined(AWS_CRT_ENABLE_VARIANT_DEBUG)
-            VariantDetail::VariantDebug::VariantDebugBrowser<Ts...> browser = m_storage;
-#endif /* defined(AWS_CRT_ENABLE_VARIANT_DEBUG) */
+                template <std::size_t Index, typename... Args>
+                auto emplace(Args &&...args) -> typename ThisVariantAlternative<Index>::type &
+                {
+                    static_assert(Index < AlternativeCount, "Unknown alternative index to emplace");
+                    using AlternativeT = typename ThisVariantAlternative<Index>::type;
 
-            template <size_t Index> constexpr bool holds_alternative() const { return Index == m_index; }
+                    return emplace<AlternativeT, Args...>(std::forward<Args>(args)...);
+                }
 
-            struct Destroyer
-            {
-                template <typename AlternativeT> void operator()(AlternativeT &&value) const
+                template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1> bool holds_alternative() const
                 {
-                    (void)value;
-                    using PlaintT = typename std::remove_reference<AlternativeT>::type;
-                    value.~PlaintT();
+                    AWS_ASSERT(m_index != -1);
+                    return m_index == VariantDetail::Index::GetIndexOf<T, Ts...>();
                 }
-            };
 
-            void Destroy()
-            {
-                AWS_FATAL_ASSERT(m_index != -1);
-                Visit(Destroyer());
-
-                m_index = -1;
-            }
-
-            struct CopyMoveConstructor
-            {
-                template <typename AlternativeT> void operator()(AlternativeT &&value, AlternativeT &&other) const
+                /* non-const get */
+                template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1> T &get()
                 {
-                    using PlaintT = typename std::remove_reference<AlternativeT>::type;
-                    new (&value) PlaintT(std::move<AlternativeT>(other));
+                    AWS_FATAL_ASSERT(holds_alternative<T>());
+                    T *value = reinterpret_cast<T *>(m_storage);
+                    return *value;
                 }
 
-                template <typename AlternativeT, typename ConstAlternativeT>
-                void operator()(AlternativeT &&value, ConstAlternativeT &other) const
+                template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1> T *get_if()
                 {
-                    using PlaintT = typename std::remove_reference<AlternativeT>::type;
-                    using PlaintOtherT =
-                        typename std::remove_const<typename std::remove_reference<AlternativeT>::type>::type;
-                    static_assert(std::is_same<PlaintT, PlaintOtherT>::value, "Incompatible types");
-
-                    new (&value) PlaintT(other);
+                    if (holds_alternative<T>())
+                    {
+                        T *value = reinterpret_cast<T *>(m_storage);
+                        return value;
+                    }
+                    else
+                    {
+                        return nullptr;
+                    }
                 }
-            };
 
-            struct CopyMoveAssigner
-            {
-                template <typename AlternativeT> void operator()(AlternativeT &&value, AlternativeT &&other) const
+                template <std::size_t Index> auto get() -> typename ThisVariantAlternative<Index>::type &
                 {
-                    value = std::move(other);
+                    static_assert(Index < AlternativeCount, "Unknown alternative index to get");
+                    AWS_FATAL_ASSERT(holds_alternative<Index>());
+                    using AlternativeT = typename ThisVariantAlternative<Index>::type;
+                    AlternativeT *ret = reinterpret_cast<AlternativeT *>(m_storage);
+                    return *ret;
                 }
 
-                template <typename AlternativeT, typename ConstAlternativeT>
-                void operator()(AlternativeT &&value, ConstAlternativeT &other) const
+                /* const get */
+                template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1> const T &get() const
                 {
-                    using PlaintT = typename std::remove_reference<AlternativeT>::type;
-                    using PlaintOtherT =
-                        typename std::remove_const<typename std::remove_reference<AlternativeT>::type>::type;
-                    static_assert(std::is_same<PlaintT, PlaintOtherT>::value, "Incompatible types");
-
-                    value = other;
+                    AWS_FATAL_ASSERT(holds_alternative<T>());
+                    const T *value = reinterpret_cast<const T *>(m_storage);
+                    return *value;
                 }
-            };
-
-            template <IndexT Index, typename... Args> struct VisitorUtil;
 
-            template <IndexT Index, typename First, typename Second, typename... Rest>
-            struct VisitorUtil<Index, First, Second, Rest...>
-            {
-                template <typename VisitorStruct> static void Visit(Variant *pThis, VisitorStruct &&visitor)
+                template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1> const T *get_if() const
                 {
-                    static_assert(Index < AlternativeCount, "Attempting to visit unknown Index Type");
-
-                    if (Index == pThis->m_index)
+                    if (holds_alternative<T>())
                     {
-                        using AlternativeT = typename ThisVariantAlternative<Index>::type;
-                        AlternativeT *value = reinterpret_cast<AlternativeT *>(pThis->m_storage);
-                        visitor(*value);
+                        T *value = reinterpret_cast<T *>(m_storage);
+                        return value;
                     }
                     else
                     {
-                        VisitorUtil<static_cast<IndexT>(Index + 1), Second, Rest...>::Visit(
-                            pThis, std::forward<VisitorStruct>(visitor));
+                        return nullptr;
                     }
                 }
 
-                template <typename VisitorStruct>
-                static void VisitBinary(Variant<Ts...> *pThis, Variant<Ts...> &&other, VisitorStruct &&visitor)
+                template <std::size_t Index> auto get() const -> const typename ThisVariantAlternative<Index>::type &
                 {
-                    static_assert(Index < AlternativeCount, "Attempting to visit unknown Index Type");
+                    static_assert(Index < AlternativeCount, "Unknown alternative index to get");
+                    AWS_ASSERT(Index == m_index);
+                    using AlternativeT = typename ThisVariantAlternative<Index>::type;
+                    const AlternativeT *ret = reinterpret_cast<const AlternativeT *>(m_storage);
+                    return *ret;
+                }
+
+                /* This is just a templated way to say
+                 * "int*" for
+                 * a VariantAlternative<0, VariantImpl<int, char, long>()>*/
+                template <std::size_t Index>
+                using RawAlternativePointerT =
+                    typename std::add_pointer<typename ThisVariantAlternative<Index>::type>::type;
 
-                    if (Index == pThis->m_index)
+                template <std::size_t Index> auto get_if() -> RawAlternativePointerT<Index>
+                {
+                    static_assert(Index < AlternativeCount, "Unknown alternative index to get");
+                    if (holds_alternative<Index>())
                     {
-                        using AlternativeT = typename ThisVariantAlternative<Index>::type;
-                        AlternativeT *value = reinterpret_cast<AlternativeT *>(pThis->m_storage);
-                        visitor(*value, other.get<AlternativeT>());
+                        using AlternativePtrT = RawAlternativePointerT<Index>;
+                        AlternativePtrT value = reinterpret_cast<AlternativePtrT>(m_storage);
+                        return value;
                     }
                     else
                     {
-                        VisitorUtil<static_cast<IndexT>(Index + 1), Second, Rest...>::VisitBinary(
-                            pThis, std::forward<Variant<Ts...>>(other), std::forward<VisitorStruct>(visitor));
+                        return nullptr;
                     }
                 }
 
-                template <typename VisitorStruct>
-                static void VisitBinary(Variant<Ts...> *pThis, const Variant<Ts...> &other, VisitorStruct &&visitor)
-                {
-                    static_assert(Index < AlternativeCount, "Attempting to visit unknown Index Type");
+                template <std::size_t Index>
+                using ConstRawAlternativePointerT = typename std::add_pointer<
+                    typename std::add_const<typename ThisVariantAlternative<Index>::type>::type>::type;
 
-                    if (Index == pThis->m_index)
+                template <std::size_t Index> auto get_if() const -> ConstRawAlternativePointerT<Index>
+                {
+                    static_assert(Index < AlternativeCount, "Unknown alternative index to get");
+                    if (holds_alternative<Index>())
                     {
-                        using AlternativeT = typename ThisVariantAlternative<Index>::type;
-                        AlternativeT *value = reinterpret_cast<AlternativeT *>(pThis->m_storage);
-                        const AlternativeT &otherValue = other.get<AlternativeT>();
-                        visitor(*value, otherValue);
+                        using AlternativePtrT = ConstRawAlternativePointerT<Index>;
+                        AlternativePtrT value = reinterpret_cast<AlternativePtrT>(m_storage);
+                        return value;
                     }
                     else
                     {
-                        VisitorUtil<static_cast<IndexT>(Index + 1), Second, Rest...>::VisitBinary(
-                            pThis, other, std::forward<VisitorStruct>(visitor));
+                        return nullptr;
                     }
                 }
-            };
 
-            template <IndexT Index, typename Last> struct VisitorUtil<Index, Last>
-            {
-                template <typename VisitorStruct> static void Visit(Variant *pThis, VisitorStruct &&visitor)
+                std::size_t index() const { return m_index; }
+
+                ~VariantImpl() { Destroy(); }
+
+                template <typename VisitorT> void Visit(VisitorT &&visitor)
                 {
-                    static_assert(Index < AlternativeCount, "Attempting to visit unknown Index Type");
+                    return VisitorUtil<0, Ts...>::Visit(this, std::forward<VisitorT>(visitor));
+                }
+
+              private:
+                static constexpr std::size_t STORAGE_SIZE = VariantDetail::ParameterPackSize::GetMaxSizeOf<Ts...>();
+
+                alignas(VariantDetail::ParameterPackSize::AlignAsPack<Ts...>()) char m_storage[STORAGE_SIZE];
+                IndexT m_index = -1;
+#if defined(AWS_CRT_ENABLE_VARIANT_DEBUG)
+                VariantDetail::VariantDebug::VariantDebugBrowser<Ts...> browser = m_storage;
+#endif /* defined(AWS_CRT_ENABLE_VARIANT_DEBUG) */
 
-                    if (Index == pThis->m_index)
+                template <size_t Index> constexpr bool holds_alternative() const { return Index == m_index; }
+
+                struct Destroyer
+                {
+                    template <typename AlternativeT> void operator()(AlternativeT &&value) const
                     {
-                        using AlternativeT = typename ThisVariantAlternative<Index>::type;
-                        AlternativeT *value = reinterpret_cast<AlternativeT *>(pThis->m_storage);
-                        visitor(*value);
+                        (void)value;
+                        using PlaintT = typename std::remove_reference<AlternativeT>::type;
+                        value.~PlaintT();
                     }
-                    else
+                };
+
+                void Destroy()
+                {
+                    AWS_FATAL_ASSERT(m_index != -1);
+                    Visit(Destroyer());
+
+                    m_index = -1;
+                }
+
+                struct CopyMoveConstructor
+                {
+                    template <typename AlternativeT> void operator()(AlternativeT &&value, AlternativeT &&other) const
                     {
-                        AWS_FATAL_ASSERT(!"Unknown variant alternative to visit!");
+                        using PlaintT = typename std::remove_reference<AlternativeT>::type;
+                        new (&value) PlaintT(std::move<AlternativeT>(other));
                     }
-                }
 
-                template <typename VisitorStruct>
-                static void VisitBinary(Variant<Ts...> *pThis, Variant<Ts...> &&other, VisitorStruct &&visitor)
+                    template <typename AlternativeT, typename ConstAlternativeT>
+                    void operator()(AlternativeT &&value, ConstAlternativeT &other) const
+                    {
+                        using PlaintT = typename std::remove_reference<AlternativeT>::type;
+                        using PlaintOtherT =
+                            typename std::remove_const<typename std::remove_reference<AlternativeT>::type>::type;
+                        static_assert(std::is_same<PlaintT, PlaintOtherT>::value, "Incompatible types");
+
+                        new (&value) PlaintT(other);
+                    }
+                };
+
+                struct CopyMoveAssigner
                 {
-                    static_assert(Index < AlternativeCount, "Attempting to visit unknown Index Type");
+                    template <typename AlternativeT> void operator()(AlternativeT &&value, AlternativeT &&other) const
+                    {
+                        value = std::move(other);
+                    }
 
-                    if (Index == pThis->m_index)
+                    template <typename AlternativeT, typename ConstAlternativeT>
+                    void operator()(AlternativeT &&value, ConstAlternativeT &other) const
                     {
-                        using AlternativeT = typename ThisVariantAlternative<Index>::type;
-                        AlternativeT *value = reinterpret_cast<AlternativeT *>(pThis->m_storage);
-                        visitor(*value, other.get<AlternativeT>());
+                        using PlaintT = typename std::remove_reference<AlternativeT>::type;
+                        using PlaintOtherT =
+                            typename std::remove_const<typename std::remove_reference<AlternativeT>::type>::type;
+                        static_assert(std::is_same<PlaintT, PlaintOtherT>::value, "Incompatible types");
+
+                        value = other;
                     }
-                    else
+                };
+
+                template <IndexT Index, typename... Args> struct VisitorUtil;
+
+                template <IndexT Index, typename First, typename Second, typename... Rest>
+                struct VisitorUtil<Index, First, Second, Rest...>
+                {
+                    template <typename VisitorStruct> static void Visit(VariantImpl *pThis, VisitorStruct &&visitor)
                     {
-                        AWS_FATAL_ASSERT(!"Unknown variant alternative to visit!");
+                        static_assert(Index < AlternativeCount, "Attempting to visit unknown Index Type");
+
+                        if (Index == pThis->m_index)
+                        {
+                            using AlternativeT = typename ThisVariantAlternative<Index>::type;
+                            AlternativeT *value = reinterpret_cast<AlternativeT *>(pThis->m_storage);
+                            visitor(*value);
+                        }
+                        else
+                        {
+                            VisitorUtil<static_cast<IndexT>(Index + 1), Second, Rest...>::Visit(
+                                pThis, std::forward<VisitorStruct>(visitor));
+                        }
                     }
-                }
 
-                template <typename VisitorStruct>
-                static void VisitBinary(Variant<Ts...> *pThis, const Variant<Ts...> &other, VisitorStruct &&visitor)
+                    template <typename VisitorStruct>
+                    static void VisitBinary(
+                        VariantImpl<Ts...> *pThis,
+                        VariantImpl<Ts...> &&other,
+                        VisitorStruct &&visitor)
+                    {
+                        static_assert(Index < AlternativeCount, "Attempting to visit unknown Index Type");
+
+                        if (Index == pThis->m_index)
+                        {
+                            using AlternativeT = typename ThisVariantAlternative<Index>::type;
+                            AlternativeT *value = reinterpret_cast<AlternativeT *>(pThis->m_storage);
+                            visitor(*value, other.get<AlternativeT>());
+                        }
+                        else
+                        {
+                            VisitorUtil<static_cast<IndexT>(Index + 1), Second, Rest...>::VisitBinary(
+                                pThis, std::forward<VariantImpl<Ts...>>(other), std::forward<VisitorStruct>(visitor));
+                        }
+                    }
+
+                    template <typename VisitorStruct>
+                    static void VisitBinary(
+                        VariantImpl<Ts...> *pThis,
+                        const VariantImpl<Ts...> &other,
+                        VisitorStruct &&visitor)
+                    {
+                        static_assert(Index < AlternativeCount, "Attempting to visit unknown Index Type");
+
+                        if (Index == pThis->m_index)
+                        {
+                            using AlternativeT = typename ThisVariantAlternative<Index>::type;
+                            AlternativeT *value = reinterpret_cast<AlternativeT *>(pThis->m_storage);
+                            const AlternativeT &otherValue = other.get<AlternativeT>();
+                            visitor(*value, otherValue);
+                        }
+                        else
+                        {
+                            VisitorUtil<static_cast<IndexT>(Index + 1), Second, Rest...>::VisitBinary(
+                                pThis, other, std::forward<VisitorStruct>(visitor));
+                        }
+                    }
+                };
+
+                template <IndexT Index, typename Last> struct VisitorUtil<Index, Last>
                 {
-                    static_assert(Index < AlternativeCount, "Attempting to visit unknown Index Type");
+                    template <typename VisitorStruct> static void Visit(VariantImpl *pThis, VisitorStruct &&visitor)
+                    {
+                        static_assert(Index < AlternativeCount, "Attempting to visit unknown Index Type");
+
+                        if (Index == pThis->m_index)
+                        {
+                            using AlternativeT = typename ThisVariantAlternative<Index>::type;
+                            AlternativeT *value = reinterpret_cast<AlternativeT *>(pThis->m_storage);
+                            visitor(*value);
+                        }
+                        else
+                        {
+                            AWS_FATAL_ASSERT(!"Unknown variant alternative to visit!");
+                        }
+                    }
 
-                    if (Index == pThis->m_index)
+                    template <typename VisitorStruct>
+                    static void VisitBinary(
+                        VariantImpl<Ts...> *pThis,
+                        VariantImpl<Ts...> &&other,
+                        VisitorStruct &&visitor)
                     {
-                        using AlternativeT = typename ThisVariantAlternative<Index>::type;
-                        AlternativeT *value = reinterpret_cast<AlternativeT *>(pThis->m_storage);
-                        const AlternativeT &otherValue = other.get<AlternativeT>();
-                        visitor(*value, otherValue);
+                        static_assert(Index < AlternativeCount, "Attempting to visit unknown Index Type");
+
+                        if (Index == pThis->m_index)
+                        {
+                            using AlternativeT = typename ThisVariantAlternative<Index>::type;
+                            AlternativeT *value = reinterpret_cast<AlternativeT *>(pThis->m_storage);
+                            visitor(*value, other.get<AlternativeT>());
+                        }
+                        else
+                        {
+                            AWS_FATAL_ASSERT(!"Unknown variant alternative to visit!");
+                        }
                     }
-                    else
+
+                    template <typename VisitorStruct>
+                    static void VisitBinary(
+                        VariantImpl<Ts...> *pThis,
+                        const VariantImpl<Ts...> &other,
+                        VisitorStruct &&visitor)
                     {
-                        AWS_FATAL_ASSERT(!"Unknown variant alternative to visit!");
+                        static_assert(Index < AlternativeCount, "Attempting to visit unknown Index Type");
+
+                        if (Index == pThis->m_index)
+                        {
+                            using AlternativeT = typename ThisVariantAlternative<Index>::type;
+                            AlternativeT *value = reinterpret_cast<AlternativeT *>(pThis->m_storage);
+                            const AlternativeT &otherValue = other.get<AlternativeT>();
+                            visitor(*value, otherValue);
+                        }
+                        else
+                        {
+                            AWS_FATAL_ASSERT(!"Unknown variant alternative to visit!");
+                        }
                     }
-                }
+                };
+            };
+
+            /* Helper template to get an actual type from an Index */
+            template <std::size_t Index, typename... Ts> class VariantAlternative
+            {
+              public:
+                // uses std::tuple as a helper struct to provide index-based access of a parameter pack
+                using type = typename std::tuple_element<Index, std::tuple<Ts...>>::type;
+
+                VariantAlternative(const VariantImpl<Ts...> &) {}
+
+                VariantAlternative(const VariantImpl<Ts...> *) {}
+            };
+
+            template <typename T> class VariantSize
+            {
+                constexpr static const std::size_t Value = T::AlternativeCount;
             };
-        };
 
-        /* Helper template to get an actual type from an Index */
-        template <std::size_t Index, typename... Ts> class VariantAlternative
+        } // namespace VariantDetail
+
+        /**
+         * Custom implementation of a Variant type. std::variant requires C++17.
+         * @tparam Ts Types of the variant value.
+         */
+        template <typename... Ts>
+        class Variant : public VariantDetail::MovableVariant<Conjunction<std::is_move_constructible<Ts>...>::value>,
+                        public VariantDetail::CopyableVariant<Conjunction<std::is_copy_constructible<Ts>...>::value>
         {
+            /* Copyability and Movability depend only on constructors (copy and move correspondingly) of the
+             * underlying types. This means that a class with move constructor but with no move assignment operator
+             * might cause compilation issues. If such a type ever needs to be supported, additional base class needs
+             * to be introduced: MoveAssignable. For now, it'll be overengineering.
+             * The same applies to copy constructor and copy assignment operator. */
+
+          private:
+            template <std::size_t Index> using ThisVariantAlternative = VariantDetail::VariantAlternative<Index, Ts...>;
+
+            template <typename OtherT>
+            using EnableIfOtherIsThisVariantAlternative = typename std::
+                enable_if<VariantDetail::Checker::HasType<typename std::decay<OtherT>::type, Ts...>::value, int>::type;
+
+            static constexpr bool isFirstAlternativeNothrowDefaultConstructible =
+                VariantDetail::VariantImpl<Ts...>::isFirstAlternativeNothrowDefaultConstructible;
+
           public:
-            // uses std::tuple as a helper struct to provide index-based access of a parameter pack
-            using type = typename std::tuple_element<Index, std::tuple<Ts...>>::type;
+            using IndexT = VariantDetail::Index::VariantIndex;
+            static constexpr std::size_t AlternativeCount = sizeof...(Ts);
 
-            VariantAlternative(const Variant<Ts...> &) {}
+            template <
+                typename T = typename VariantDetail::VariantImpl<Ts...>::FirstAlternative,
+                typename std::enable_if<std::is_default_constructible<T>::value, bool>::type = true>
+            Variant() noexcept(isFirstAlternativeNothrowDefaultConstructible)
+            {
+            }
 
-            VariantAlternative(const Variant<Ts...> *) {}
-        };
+            template <
+                typename T = typename VariantDetail::VariantImpl<Ts...>::FirstAlternative,
+                typename std::enable_if<!std::is_default_constructible<T>::value, bool>::type = true>
+            Variant() = delete;
 
-        template <typename T> class VariantSize
-        {
-            constexpr static const std::size_t Value = T::AlternativeCount;
+            template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1>
+            Variant(const T &val) noexcept(
+                std::is_nothrow_constructible<typename std::decay<T>::type, decltype(val)>::value)
+                : m_variant(val)
+            {
+            }
+
+            template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1>
+            Variant(T &&val) noexcept(std::is_nothrow_constructible<typename std::decay<T>::type, decltype(val)>::value)
+                : m_variant(std::forward<T>(val))
+            {
+            }
+
+            template <typename T, typename... Args>
+            explicit Variant(Aws::Crt::InPlaceTypeT<T> ipt, Args &&...args)
+                : m_variant(ipt, std::forward<Args>(args)...)
+            {
+            }
+
+            template <typename T, typename... Args, EnableIfOtherIsThisVariantAlternative<T> = 1>
+            T &emplace(Args &&...args)
+            {
+                return m_variant.template emplace<T>(std::forward<Args>(args)...);
+            }
+
+            template <std::size_t Index, typename... Args>
+            auto emplace(Args &&...args) -> typename ThisVariantAlternative<Index>::type &
+            {
+                return m_variant.template emplace<Index>(std::forward<Args>(args)...);
+            }
+
+            template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1> bool holds_alternative() const
+            {
+                return m_variant.template holds_alternative<T>();
+            }
+
+            template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1> T &get()
+            {
+                return m_variant.template get<T>();
+            }
+
+            template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1> T *get_if()
+            {
+                return m_variant.template get_if<T>();
+            }
+
+            template <std::size_t Index> auto get() -> typename ThisVariantAlternative<Index>::type &
+            {
+                return m_variant.template get<Index>();
+            }
+
+            template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1> const T &get() const
+            {
+                return m_variant.template get<T>();
+            }
+
+            template <typename T, EnableIfOtherIsThisVariantAlternative<T> = 1> const T *get_if() const
+            {
+                return m_variant.template get_if<T>();
+            }
+
+            template <std::size_t Index> auto get() const -> const typename ThisVariantAlternative<Index>::type &
+            {
+                return m_variant.template get<Index>();
+            }
+
+            template <std::size_t Index>
+            using RawAlternativePointerT =
+                typename std::add_pointer<typename ThisVariantAlternative<Index>::type>::type;
+
+            template <std::size_t Index> auto get_if() -> RawAlternativePointerT<Index>
+            {
+                return m_variant.template get_if<Index>();
+            }
+
+            template <std::size_t Index>
+            using ConstRawAlternativePointerT = typename std::add_pointer<
+                typename std::add_const<typename ThisVariantAlternative<Index>::type>::type>::type;
+
+            template <std::size_t Index> auto get_if() const -> ConstRawAlternativePointerT<Index>
+            {
+                return m_variant.template get_if<Index>();
+            }
+
+            std::size_t index() const { return m_variant.index(); }
+
+            template <typename VisitorT> void Visit(VisitorT &&visitor)
+            {
+                m_variant.Visit(std::forward<VisitorT>(visitor));
+            }
+
+          private:
+            VariantDetail::VariantImpl<Ts...> m_variant;
         };
+
     } // namespace Crt
 } // namespace Aws
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index df86e33de..fc6743b4a 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -105,7 +105,13 @@ add_test_case(OptionalEmplace)
 add_test_case(OptionalCopyAndMoveSemantics)
 add_test_case(VariantCompiles)
 add_test_case(VariantConstructor)
-add_test_case(VariantOperatorEquals)
+add_test_case(VariantAssignmentOperator)
+add_test_case(VariantWithMoveOnlyUnderlyingType)
+add_test_case(VariantWithCopyOnlyUnderlyingType)
+add_test_case(VariantWithNoDefaultConstructibleUnderlyingType)
+add_test_case(VariantExceptionSafety_DefaultConstructor)
+add_test_case(VariantExceptionSafety_MoveConstructor)
+add_test_case(VariantExceptionSafety_CopyConstructor)
 add_test_case(VariantEmplace)
 add_test_case(VariantVisitor)
 add_test_case(StreamTestCreateDestroyWrapper)
diff --git a/tests/VariantTest.cpp b/tests/VariantTest.cpp
index 684d0c50e..80e6a7c8a 100644
--- a/tests/VariantTest.cpp
+++ b/tests/VariantTest.cpp
@@ -6,6 +6,12 @@
 #include <aws/crt/Variant.h>
 #include <aws/testing/aws_test_harness.h>
 
+#if defined(_WIN32)
+#    define AWS_VARIANTTEST_WINDOWS_API __declspec(dllexport)
+#else
+#    define AWS_VARIANTTEST_WINDOWS_API
+#endif
+
 const char *s_variant_test_str = "This is a string, that should be long enough to avoid small string optimizations";
 
 static int s_VariantBasicOperandsCompile(struct aws_allocator *allocator, void *ctx)
@@ -170,7 +176,7 @@ static int s_VariantConstructor(struct aws_allocator *allocator, void *ctx)
 
 AWS_TEST_CASE(VariantConstructor, s_VariantConstructor)
 
-static int s_VariantOperatorEquals(struct aws_allocator *allocator, void *ctx)
+static int s_VariantAssignmentOperator(struct aws_allocator *allocator, void *ctx)
 {
     (void)ctx;
     {
@@ -214,7 +220,192 @@ static int s_VariantOperatorEquals(struct aws_allocator *allocator, void *ctx)
     return AWS_OP_SUCCESS;
 }
 
-AWS_TEST_CASE(VariantOperatorEquals, s_VariantOperatorEquals)
+AWS_TEST_CASE(VariantAssignmentOperator, s_VariantAssignmentOperator)
+
+// Test Variant with move-only underlying type.
+// If it compiles, it's considered success.
+static int s_VariantWithMoveOnlyUnderlyingType(struct aws_allocator *allocator, void *ctx)
+{
+    (void)ctx;
+
+    Aws::Crt::ApiHandle apiHandle(allocator);
+
+    struct MoveOnlyTestType
+    {
+        MoveOnlyTestType() = default;
+
+        MoveOnlyTestType(MoveOnlyTestType &&) = default;
+        MoveOnlyTestType &operator=(MoveOnlyTestType &&) = default;
+
+        MoveOnlyTestType(const MoveOnlyTestType &) = delete;
+        MoveOnlyTestType &operator=(const MoveOnlyTestType &) = delete;
+    };
+
+    using MoveOnlyVariant = Aws::Crt::Variant<MoveOnlyTestType>;
+
+    /* Regression test.
+     * The __declspec(dllexport) directive exports class member function on Windows platform. We enable it when
+     * building shared libraries. In the past, this directive caused msvc to generate special copy members for classes
+     * containing Crt::Variant with move-only underlying types, which led to compile-time errors. */
+    struct AWS_VARIANTTEST_WINDOWS_API MoveOnlyVariantTestResult
+    {
+        MoveOnlyVariant m_result;
+    };
+
+    return AWS_OP_SUCCESS;
+}
+
+AWS_TEST_CASE(VariantWithMoveOnlyUnderlyingType, s_VariantWithMoveOnlyUnderlyingType)
+
+// Test Variant with copy-only underlying type.
+// If it compiles, it's considered success.
+static int s_VariantWithCopyOnlyUnderlyingType(struct aws_allocator *allocator, void *ctx)
+{
+    (void)ctx;
+
+    Aws::Crt::ApiHandle apiHandle(allocator);
+
+    struct CopyOnlyTestType
+    {
+        CopyOnlyTestType() = default;
+
+        CopyOnlyTestType(CopyOnlyTestType &&) = default;
+        CopyOnlyTestType &operator=(CopyOnlyTestType &&) = default;
+
+        CopyOnlyTestType(const CopyOnlyTestType &) = delete;
+        CopyOnlyTestType &operator=(const CopyOnlyTestType &) = delete;
+    };
+
+    using CopyOnlyVariant = Aws::Crt::Variant<CopyOnlyTestType>;
+
+    /* Regression test.
+     * The __declspec(dllexport) directive exports class member function on Windows platform. We enable it when
+     * building shared libraries. In the past, this directive caused msvc to generate special copy members for classes
+     * containing Crt::Variant with copy-only underlying types, which led to compile-time errors. */
+    struct AWS_VARIANTTEST_WINDOWS_API CopyOnlyVariantTestResult
+    {
+        CopyOnlyVariant m_result;
+    };
+
+    return AWS_OP_SUCCESS;
+}
+
+AWS_TEST_CASE(VariantWithCopyOnlyUnderlyingType, s_VariantWithCopyOnlyUnderlyingType)
+
+// Test Variant with underlying type without default constructor.
+// If it compiles, it's considered success.
+static int s_VariantWithNoDefaultConstructibleUnderlyingType(struct aws_allocator *allocator, void *ctx)
+{
+    (void)ctx;
+
+    Aws::Crt::ApiHandle apiHandle(allocator);
+
+    struct NoDefaultConstructibleTestType
+    {
+        explicit NoDefaultConstructibleTestType(int) {}
+        NoDefaultConstructibleTestType() = delete;
+    };
+
+    using NoDefaultConstructibleVariant = Aws::Crt::Variant<NoDefaultConstructibleTestType>;
+
+    struct AWS_VARIANTTEST_WINDOWS_API NoDefaultConstructibleVariantTestResult
+    {
+        NoDefaultConstructibleVariant m_result;
+    };
+
+    NoDefaultConstructibleTestType testType(1);
+    NoDefaultConstructibleVariant variant(testType);
+    NoDefaultConstructibleVariantTestResult testResult{variant};
+
+    return AWS_OP_SUCCESS;
+}
+
+AWS_TEST_CASE(VariantWithNoDefaultConstructibleUnderlyingType, s_VariantWithNoDefaultConstructibleUnderlyingType)
+
+static int s_VariantExceptionSafety_DefaultConstructor(struct aws_allocator *allocator, void *ctx)
+{
+    (void)ctx;
+
+    Aws::Crt::ApiHandle apiHandle(allocator);
+
+    struct NothrowDefaultConstructibleTestType
+    {
+        NothrowDefaultConstructibleTestType() noexcept {}
+        NothrowDefaultConstructibleTestType(const NothrowDefaultConstructibleTestType &) noexcept(false) {}
+        NothrowDefaultConstructibleTestType(NothrowDefaultConstructibleTestType &&) noexcept(false) {}
+    };
+
+    using NothrowDefaultConstructibleVariant = Aws::Crt::Variant<NothrowDefaultConstructibleTestType>;
+
+    ASSERT_TRUE(std::is_nothrow_constructible<NothrowDefaultConstructibleVariant>::value);
+    ASSERT_FALSE((
+        std::is_nothrow_constructible<NothrowDefaultConstructibleVariant, const NothrowDefaultConstructibleTestType &>::
+            value));
+    ASSERT_FALSE(
+        (std::is_nothrow_constructible<NothrowDefaultConstructibleVariant, NothrowDefaultConstructibleTestType &&>::
+             value));
+
+    return AWS_OP_SUCCESS;
+}
+
+AWS_TEST_CASE(VariantExceptionSafety_DefaultConstructor, s_VariantExceptionSafety_DefaultConstructor)
+
+static int s_VariantExceptionSafety_MoveConstructor(struct aws_allocator *allocator, void *ctx)
+{
+    (void)ctx;
+
+    Aws::Crt::ApiHandle apiHandle(allocator);
+
+    struct NothrowMoveConstructibleTestType
+    {
+        NothrowMoveConstructibleTestType(NothrowMoveConstructibleTestType &&) noexcept {}
+
+        NothrowMoveConstructibleTestType() noexcept(false) {}
+        NothrowMoveConstructibleTestType(const NothrowMoveConstructibleTestType &) noexcept(false) {}
+    };
+
+    using NothrowMoveConstructibleVariant = Aws::Crt::Variant<NothrowMoveConstructibleTestType>;
+
+    ASSERT_TRUE(
+        (std::is_nothrow_constructible<NothrowMoveConstructibleVariant, NothrowMoveConstructibleTestType &&>::value));
+    ASSERT_FALSE(std::is_nothrow_constructible<NothrowMoveConstructibleVariant>::value);
+    ASSERT_FALSE(
+        (std::is_nothrow_constructible<NothrowMoveConstructibleVariant, const NothrowMoveConstructibleTestType &>::
+             value));
+
+    return AWS_OP_SUCCESS;
+}
+
+AWS_TEST_CASE(VariantExceptionSafety_MoveConstructor, s_VariantExceptionSafety_MoveConstructor)
+
+static int s_VariantExceptionSafety_CopyConstructor(struct aws_allocator *allocator, void *ctx)
+{
+    (void)ctx;
+
+    Aws::Crt::ApiHandle apiHandle(allocator);
+
+    struct NothrowCopyConstructibleTestType
+    {
+        NothrowCopyConstructibleTestType(const NothrowCopyConstructibleTestType &) noexcept {}
+
+        NothrowCopyConstructibleTestType() noexcept(false) {}
+        NothrowCopyConstructibleTestType(NothrowCopyConstructibleTestType &&) noexcept(false) {}
+    };
+
+    using NothrowCopyConstructibleVariant = Aws::Crt::Variant<NothrowCopyConstructibleTestType>;
+
+    ASSERT_TRUE(
+        (std::is_nothrow_constructible<NothrowCopyConstructibleVariant, const NothrowCopyConstructibleTestType &>::
+             value));
+
+    ASSERT_FALSE(std::is_nothrow_constructible<NothrowCopyConstructibleVariant>::value);
+    ASSERT_FALSE(
+        (std::is_nothrow_constructible<NothrowCopyConstructibleVariant, NothrowCopyConstructibleTestType &&>::value));
+
+    return AWS_OP_SUCCESS;
+}
+
+AWS_TEST_CASE(VariantExceptionSafety_CopyConstructor, s_VariantExceptionSafety_CopyConstructor)
 
 struct TestStringOnlyVisitor
 {
@@ -364,4 +555,4 @@ static int s_VariantVisitor(struct aws_allocator *allocator, void *ctx)
     return AWS_OP_SUCCESS;
 }
 
-AWS_TEST_CASE(VariantVisitor, s_VariantVisitor)
\ No newline at end of file
+AWS_TEST_CASE(VariantVisitor, s_VariantVisitor)