diff --git a/VERSION b/VERSION
index 989b29cc3..d721c7684 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.32.2
+0.32.3
diff --git a/include/aws/crt/Optional.h b/include/aws/crt/Optional.h
index 220b652d6..1a7e24a90 100644
--- a/include/aws/crt/Optional.h
+++ b/include/aws/crt/Optional.h
@@ -3,6 +3,7 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0.
  */
+#include <aws/crt/TypeTraits.h>
 #include <aws/crt/Utility.h>
 #include <utility>
 
@@ -17,6 +18,8 @@ namespace Aws
         template <typename T> class Optional
         {
           public:
+            using ValueType = T;
+
             Optional() : m_value(nullptr) {}
             Optional(const T &val)
             {
@@ -38,7 +41,15 @@ namespace Aws
                 }
             }
 
-            template <typename U = T> Optional &operator=(U &&u)
+            /**
+             * Assignment operator for a case when the parameter type is not Optional.
+             */
+            template <
+                typename U = T,
+                typename std::enable_if<
+                    !IsSpecializationOf<typename std::decay<U>::type, Aws::Crt::Optional>::value,
+                    bool>::type = true>
+            Optional &operator=(U &&u)
             {
                 if (m_value)
                 {
@@ -84,98 +95,11 @@ namespace Aws
                 m_value = reinterpret_cast<T *>(m_storage);
             }
 
-            Optional &operator=(const Optional &other)
-            {
-                if (this == &other)
-                {
-                    return *this;
-                }
-
-                if (m_value)
-                {
-                    if (other.m_value)
-                    {
-                        *m_value = *other.m_value;
-                    }
-                    else
-                    {
-                        m_value->~T();
-                        m_value = nullptr;
-                    }
-
-                    return *this;
-                }
-
-                if (other.m_value)
-                {
-                    new (m_storage) T(*other.m_value);
-                    m_value = reinterpret_cast<T *>(m_storage);
-                }
-
-                return *this;
-            }
-
-            template <typename U = T> Optional<T> &operator=(const Optional<U> &other)
-            {
-                if (this == &other)
-                {
-                    return *this;
-                }
-
-                if (m_value)
-                {
-                    if (other.m_value)
-                    {
-                        *m_value = *other.m_value;
-                    }
-                    else
-                    {
-                        m_value->~T();
-                        m_value = nullptr;
-                    }
-
-                    return *this;
-                }
-
-                if (other.m_value)
-                {
-                    new (m_storage) T(*other.m_value);
-                    m_value = reinterpret_cast<T *>(m_storage);
-                }
-
-                return *this;
-            }
-
-            template <typename U = T> Optional<T> &operator=(Optional<U> &&other)
-            {
-                if (this == &other)
-                {
-                    return *this;
-                }
-
-                if (m_value)
-                {
-                    if (other.m_value)
-                    {
-                        *m_value = std::forward<U>(*other.m_value);
-                    }
-                    else
-                    {
-                        m_value->~T();
-                        m_value = nullptr;
-                    }
-
-                    return *this;
-                }
+            Optional<T> &operator=(const Optional &other) { return assign(other); }
 
-                if (other.m_value)
-                {
-                    new (m_storage) T(std::forward<U>(*other.m_value));
-                    m_value = reinterpret_cast<T *>(m_storage);
-                }
+            template <typename U = T> Optional<T> &operator=(const Optional<U> &other) { return assign(other); }
 
-                return *this;
-            }
+            template <typename U = T> Optional<T> &operator=(Optional<U> &&other) { return assign(std::move(other)); }
 
             template <typename... Args> T &emplace(Args &&...args)
             {
@@ -213,6 +137,47 @@ namespace Aws
             }
 
           private:
+            template <typename Op> Optional &assign(Op &&other)
+            {
+                // U is an underlying type of the Optional type passed to this function. Depending on constness of Op,
+                // U will be either value or const ref.
+                // NOTE: std::is_const<const C&> == false, that's why std::remove_reference is needed here.
+                using U = typename std::conditional<
+                    std::is_const<typename std::remove_reference<Op>::type>::value,
+                    const typename std::decay<Op>::type::ValueType &,
+                    typename std::decay<Op>::type::ValueType>::type;
+
+                if ((void *)this == (void *)&other)
+                {
+                    return *this;
+                }
+
+                if (m_value)
+                {
+                    // Optional<U> is a completely different class from the C++ specifics pov. So, we can use only
+                    // public members of `other`.
+                    if (other.has_value())
+                    {
+                        *m_value = std::forward<U>(other.value());
+                    }
+                    else
+                    {
+                        m_value->~T();
+                        m_value = nullptr;
+                    }
+
+                    return *this;
+                }
+
+                if (other.has_value())
+                {
+                    new (m_storage) T(std::forward<U>(other.value()));
+                    m_value = reinterpret_cast<T *>(m_storage);
+                }
+
+                return *this;
+            }
+
             alignas(T) char m_storage[sizeof(T)];
             T *m_value;
         };
diff --git a/include/aws/crt/StringView.h b/include/aws/crt/StringView.h
index 3b6dc2f0f..730c1391e 100644
--- a/include/aws/crt/StringView.h
+++ b/include/aws/crt/StringView.h
@@ -820,25 +820,35 @@ namespace Aws
         {
             inline namespace string_view_literals
             {
-                inline basic_string_view<char> operator"" _sv(const char *s, size_t length) noexcept
+#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ == 4 && __GNUC_MINOR__ <= 8)
+/* On GCC <= 4.8, use old syntax for literal operator (with space after ""). It can't do the modern syntax */
+#    define OPERATOR_LITERAL_SV operator"" _sv
+#else
+/* else use modern syntax (no space after "") to avoid -Wdeprecated-literal-operator warning on Clang 16+ */
+#    define OPERATOR_LITERAL_SV operator""_sv
+#endif
+
+                inline basic_string_view<char> OPERATOR_LITERAL_SV(const char *s, size_t length) noexcept
                 {
                     return basic_string_view<char>(s, length);
                 }
 
-                inline basic_string_view<wchar_t> operator"" _sv(const wchar_t * s, size_t length) noexcept
+                inline basic_string_view<wchar_t> OPERATOR_LITERAL_SV(const wchar_t *s, size_t length) noexcept
                 {
                     return basic_string_view<wchar_t>(s, length);
                 }
 
-                inline basic_string_view<char16_t> operator"" _sv(const char16_t *s, size_t length) noexcept
+                inline basic_string_view<char16_t> OPERATOR_LITERAL_SV(const char16_t *s, size_t length) noexcept
                 {
                     return basic_string_view<char16_t>(s, length);
                 }
 
-                inline basic_string_view<char32_t> operator"" _sv(const char32_t *s, size_t length) noexcept
+                inline basic_string_view<char32_t> OPERATOR_LITERAL_SV(const char32_t *s, size_t length) noexcept
                 {
                     return basic_string_view<char32_t>(s, length);
                 }
+
+#undef OPERATOR_LITERAL_SV
             } // namespace string_view_literals
 
         } // namespace literals
diff --git a/include/aws/crt/TypeTraits.h b/include/aws/crt/TypeTraits.h
new file mode 100644
index 000000000..72ed9d9a6
--- /dev/null
+++ b/include/aws/crt/TypeTraits.h
@@ -0,0 +1,30 @@
+#pragma once
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <type_traits>
+
+namespace Aws
+{
+    namespace Crt
+    {
+        /**
+         * A type trait for determining if the first template parameter is a template specialization of the second
+         * template parameter. Based on p2098 (https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2098r1.pdf).
+         *
+         * @note Known limitations: does not support template classes with non-type template parameter, e.g. std::array.
+         */
+        template <typename T, template <typename...> class Primary> struct IsSpecializationOf : std::false_type
+        {
+        };
+
+        /* Specialization for the case when the first template parameter is a template specialization of the second
+         * template parameter. */
+        template <template <typename...> class Primary, typename... Args>
+        struct IsSpecializationOf<Primary<Args...>, Primary> : std::true_type
+        {
+        };
+    } // namespace Crt
+} // namespace Aws
diff --git a/tests/OptionalMemorySafetyTest.cpp b/tests/OptionalMemorySafetyTest.cpp
index 29957b5a2..31025a1ed 100644
--- a/tests/OptionalMemorySafetyTest.cpp
+++ b/tests/OptionalMemorySafetyTest.cpp
@@ -107,7 +107,14 @@ AWS_TEST_CASE(OptionalEmplace, s_OptionalEmplace)
 class CopyMoveTester
 {
   public:
-    CopyMoveTester() : m_copied(false), m_moved(false) {}
+    struct Initer
+    {
+    };
+
+    CopyMoveTester() = default;
+    explicit CopyMoveTester(const Initer &) : m_initer_copied(true) {}
+    explicit CopyMoveTester(Initer &&) : m_initer_moved(true) {}
+
     CopyMoveTester(const CopyMoveTester &) : m_copied(true), m_moved(false) {}
     CopyMoveTester(CopyMoveTester &&) : m_copied(false), m_moved(true) {}
 
@@ -115,19 +122,43 @@ class CopyMoveTester
     {
         m_copied = true;
         m_moved = false;
+        m_initer_copied = false;
+        m_initer_moved = false;
         return *this;
     }
     CopyMoveTester &operator=(CopyMoveTester &&)
     {
         m_copied = false;
         m_moved = true;
+        m_initer_copied = false;
+        m_initer_moved = false;
+        return *this;
+    }
+
+    CopyMoveTester &operator=(const Initer &)
+    {
+        m_copied = false;
+        m_moved = false;
+        m_initer_copied = true;
+        m_initer_moved = false;
+        return *this;
+    }
+
+    CopyMoveTester &operator=(Initer &&)
+    {
+        m_copied = false;
+        m_moved = false;
+        m_initer_copied = false;
+        m_initer_moved = true;
         return *this;
     }
 
     ~CopyMoveTester() {}
 
-    bool m_copied;
-    bool m_moved;
+    bool m_copied = false;
+    bool m_moved = false;
+    bool m_initer_copied = false;
+    bool m_initer_moved = false;
 };
 
 static int s_OptionalCopyAndMoveSemantics(struct aws_allocator *allocator, void *ctx)
@@ -140,40 +171,163 @@ static int s_OptionalCopyAndMoveSemantics(struct aws_allocator *allocator, void
         ASSERT_FALSE(initialItem.m_copied);
         ASSERT_FALSE(initialItem.m_moved);
 
-        Aws::Crt::Optional<CopyMoveTester> copyConstructedValue(initialItem);
-        ASSERT_TRUE(copyConstructedValue->m_copied);
-        ASSERT_FALSE(copyConstructedValue->m_moved);
-
-        Aws::Crt::Optional<CopyMoveTester> copyConstructedOptional(copyConstructedValue);
-        ASSERT_TRUE(copyConstructedOptional->m_copied);
-        ASSERT_FALSE(copyConstructedOptional->m_moved);
-
-        Aws::Crt::Optional<CopyMoveTester> copyAssignedValue = initialItem;
-        ASSERT_TRUE(copyAssignedValue->m_copied);
-        ASSERT_FALSE(copyAssignedValue->m_moved);
-
-        Aws::Crt::Optional<CopyMoveTester> copyAssignedOptional = copyConstructedOptional;
-        ASSERT_TRUE(copyAssignedOptional->m_copied);
-        ASSERT_FALSE(copyAssignedOptional->m_moved);
-
-        Aws::Crt::Optional<CopyMoveTester> moveConstructedValue(std::move(initialItem));
-        ASSERT_FALSE(moveConstructedValue->m_copied);
-        ASSERT_TRUE(moveConstructedValue->m_moved);
-
-        Aws::Crt::Optional<CopyMoveTester> moveConstructedOptional(std::move(moveConstructedValue));
-        ASSERT_FALSE(moveConstructedOptional->m_copied);
-        ASSERT_TRUE(moveConstructedOptional->m_moved);
-
-        Aws::Crt::Optional<CopyMoveTester> moveAssignedValue = std::move(*moveConstructedOptional);
-        ASSERT_FALSE(moveAssignedValue->m_copied);
-        ASSERT_TRUE(moveAssignedValue->m_moved);
-
-        Aws::Crt::Optional<CopyMoveTester> moveAssignedOptional = std::move(moveAssignedValue);
-        ASSERT_FALSE(moveAssignedOptional->m_copied);
-        ASSERT_TRUE(moveAssignedOptional->m_moved);
+        {
+            // Optional(const U&), where U == T
+            Aws::Crt::Optional<CopyMoveTester> copyConstructedValue(initialItem);
+            ASSERT_TRUE(copyConstructedValue->m_copied);
+            ASSERT_FALSE(copyConstructedValue->m_moved);
+
+            // Optional(const Optional<U>&), where U == T
+            Aws::Crt::Optional<CopyMoveTester> copyConstructedOptional(copyConstructedValue);
+            ASSERT_TRUE(copyConstructedOptional->m_copied);
+            ASSERT_FALSE(copyConstructedOptional->m_moved);
+        }
+
+        {
+            // operator=(const U&), where U == T
+            Aws::Crt::Optional<CopyMoveTester> copyAssignedValue;
+            // Assignment to empty Optional.
+            copyAssignedValue = initialItem;
+            ASSERT_TRUE(copyAssignedValue->m_copied);
+            ASSERT_FALSE(copyAssignedValue->m_moved);
+            // Assignment to non-empty Optional.
+            copyAssignedValue = initialItem;
+            ASSERT_TRUE(copyAssignedValue->m_copied);
+            ASSERT_FALSE(copyAssignedValue->m_moved);
+        }
+
+        {
+            // operator=(const U&), where U != T
+            Aws::Crt::Optional<CopyMoveTester> copyAssignedOtherValue;
+            CopyMoveTester::Initer copyIniter;
+            // Assignment to empty Optional.
+            copyAssignedOtherValue = copyIniter;
+            ASSERT_FALSE(copyAssignedOtherValue->m_copied);
+            ASSERT_FALSE(copyAssignedOtherValue->m_moved);
+            ASSERT_TRUE(copyAssignedOtherValue->m_initer_copied);
+            ASSERT_FALSE(copyAssignedOtherValue->m_initer_moved);
+            // Assignment to non-empty Optional.
+            copyAssignedOtherValue = copyIniter;
+            ASSERT_FALSE(copyAssignedOtherValue->m_copied);
+            ASSERT_FALSE(copyAssignedOtherValue->m_moved);
+            ASSERT_TRUE(copyAssignedOtherValue->m_initer_copied);
+            ASSERT_FALSE(copyAssignedOtherValue->m_initer_moved);
+        }
+
+        {
+            // operator=(const Optional<U>&), where U == T
+            Aws::Crt::Optional<CopyMoveTester> copyAssignedOptional;
+            Aws::Crt::Optional<CopyMoveTester> tester = CopyMoveTester();
+            // Assignment to empty Optional.
+            copyAssignedOptional = tester;
+            ASSERT_TRUE(copyAssignedOptional->m_copied);
+            ASSERT_FALSE(copyAssignedOptional->m_moved);
+            // Assignment to non-empty Optional.
+            copyAssignedOptional = tester;
+            ASSERT_TRUE(copyAssignedOptional->m_copied);
+            ASSERT_FALSE(copyAssignedOptional->m_moved);
+        }
+
+        {
+            // operator=(const Optional<U>&), where U != T
+            Aws::Crt::Optional<CopyMoveTester> copyAssignedOtherOptional;
+            Aws::Crt::Optional<CopyMoveTester::Initer> copyIniterOptional = CopyMoveTester::Initer();
+            // Assignment to empty Optional.
+            copyAssignedOtherOptional = copyIniterOptional;
+            ASSERT_FALSE(copyAssignedOtherOptional->m_copied);
+            ASSERT_FALSE(copyAssignedOtherOptional->m_moved);
+            ASSERT_TRUE(copyAssignedOtherOptional->m_initer_copied);
+            ASSERT_FALSE(copyAssignedOtherOptional->m_initer_moved);
+            // Assignment to non-empty Optional.
+            copyAssignedOtherOptional = copyIniterOptional;
+            ASSERT_FALSE(copyAssignedOtherOptional->m_copied);
+            ASSERT_FALSE(copyAssignedOtherOptional->m_moved);
+            ASSERT_TRUE(copyAssignedOtherOptional->m_initer_copied);
+            ASSERT_FALSE(copyAssignedOtherOptional->m_initer_moved);
+        }
+
+        {
+            // Optional(U&&), where U == T
+            Aws::Crt::Optional<CopyMoveTester> moveConstructedValue(std::move(initialItem));
+            ASSERT_FALSE(moveConstructedValue->m_copied);
+            ASSERT_TRUE(moveConstructedValue->m_moved);
+
+            // Optional(Optional<U>&&), where U == T
+            Aws::Crt::Optional<CopyMoveTester> moveConstructedOptional(std::move(moveConstructedValue));
+            ASSERT_FALSE(moveConstructedOptional->m_copied);
+            ASSERT_TRUE(moveConstructedOptional->m_moved);
+        }
+
+        {
+            // operator=(U&&), where U == T
+            Aws::Crt::Optional<CopyMoveTester> moveAssignedValue;
+            CopyMoveTester tester;
+            // Assignment to empty Optional.
+            moveAssignedValue = std::move(tester);
+            ASSERT_FALSE(moveAssignedValue->m_copied);
+            ASSERT_TRUE(moveAssignedValue->m_moved);
+            // Assignment to non-empty Optional.
+            tester = CopyMoveTester();
+            moveAssignedValue = std::move(tester);
+            ASSERT_FALSE(moveAssignedValue->m_copied);
+            ASSERT_TRUE(moveAssignedValue->m_moved);
+        }
+
+        {
+            // operator=(U&&), where U != T
+            Aws::Crt::Optional<CopyMoveTester> moveAssignedOtherValue;
+            CopyMoveTester::Initer moveIniter;
+            // Assignment to empty Optional.
+            moveAssignedOtherValue = std::move(moveIniter);
+            ASSERT_FALSE(moveAssignedOtherValue->m_copied);
+            ASSERT_FALSE(moveAssignedOtherValue->m_moved);
+            ASSERT_FALSE(moveAssignedOtherValue->m_initer_copied);
+            ASSERT_TRUE(moveAssignedOtherValue->m_initer_moved);
+            // Assignment to non-empty Optional.
+            moveIniter = CopyMoveTester::Initer();
+            moveAssignedOtherValue = std::move(moveIniter);
+            ASSERT_FALSE(moveAssignedOtherValue->m_copied);
+            ASSERT_FALSE(moveAssignedOtherValue->m_moved);
+            ASSERT_FALSE(moveAssignedOtherValue->m_initer_copied);
+            ASSERT_TRUE(moveAssignedOtherValue->m_initer_moved);
+        }
+
+        {
+            // operator=(Optional<U>&&), where U == T
+            Aws::Crt::Optional<CopyMoveTester> moveAssignedOptional;
+            Aws::Crt::Optional<CopyMoveTester> tester = CopyMoveTester();
+            // Assignment to empty Optional.
+            moveAssignedOptional = std::move(tester);
+            ASSERT_FALSE(moveAssignedOptional->m_copied);
+            ASSERT_TRUE(moveAssignedOptional->m_moved);
+            // Assignment to non-empty Optional.
+            tester = CopyMoveTester();
+            moveAssignedOptional = std::move(tester);
+            ASSERT_FALSE(moveAssignedOptional->m_copied);
+            ASSERT_TRUE(moveAssignedOptional->m_moved);
+        }
+
+        {
+            // operator=(Optional<U>&&), where U != T
+            Aws::Crt::Optional<CopyMoveTester> moveAssignedOtherOptional;
+            Aws::Crt::Optional<CopyMoveTester::Initer> moveIniterOptional = CopyMoveTester::Initer();
+            // Assignment to empty Optional.
+            moveAssignedOtherOptional = std::move(moveIniterOptional);
+            ASSERT_FALSE(moveAssignedOtherOptional->m_copied);
+            ASSERT_FALSE(moveAssignedOtherOptional->m_moved);
+            ASSERT_FALSE(moveAssignedOtherOptional->m_initer_copied);
+            ASSERT_TRUE(moveAssignedOtherOptional->m_initer_moved);
+            // Assignment to non-empty Optional.
+            moveIniterOptional = CopyMoveTester::Initer();
+            moveAssignedOtherOptional = std::move(moveIniterOptional);
+            ASSERT_FALSE(moveAssignedOtherOptional->m_copied);
+            ASSERT_FALSE(moveAssignedOtherOptional->m_moved);
+            ASSERT_FALSE(moveAssignedOtherOptional->m_initer_copied);
+            ASSERT_TRUE(moveAssignedOtherOptional->m_initer_moved);
+        }
     }
 
     return AWS_OP_SUCCESS;
 }
 
-AWS_TEST_CASE(OptionalCopyAndMoveSemantics, s_OptionalCopyAndMoveSemantics)
\ No newline at end of file
+AWS_TEST_CASE(OptionalCopyAndMoveSemantics, s_OptionalCopyAndMoveSemantics)