diff --git a/CMakeLists.txt b/CMakeLists.txt
index 13eac822..a5870f8d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -73,7 +73,7 @@ target_include_directories(EASTL PUBLIC include)
 FetchContent_Declare(
   EABase
   GIT_REPOSITORY https://github.com/electronicarts/EABase.git
-  GIT_TAG        c11d898e3d175c9e957df86e4afe5403429f57f1
+  GIT_TAG        123363eb82e132c0181ac53e43226d8ee76dea12
   GIT_SUBMODULES "" # This should be temporary until we update the cyclic submodule dependencies in EABase.
 )
 
diff --git a/benchmark/source/BenchmarkDeque.cpp b/benchmark/source/BenchmarkDeque.cpp
index a182471e..2d06bf79 100644
--- a/benchmark/source/BenchmarkDeque.cpp
+++ b/benchmark/source/BenchmarkDeque.cpp
@@ -56,15 +56,6 @@ namespace
 }
 
 
-EASTL_DECLARE_POD(ValuePair)
-EASTL_DECLARE_TRIVIAL_CONSTRUCTOR(ValuePair)
-EASTL_DECLARE_TRIVIAL_COPY(ValuePair)
-EASTL_DECLARE_TRIVIAL_ASSIGN(ValuePair)
-EASTL_DECLARE_TRIVIAL_DESTRUCTOR(ValuePair)
-EASTL_DECLARE_TRIVIAL_RELOCATE(ValuePair)
-
-
-
 typedef std::deque<ValuePair>   StdDeque;
 typedef eastl::deque<ValuePair, EASTLAllocatorType, 128> EaDeque;  // What value do we pick for the subarray size to make the comparison fair? Using the default isn't ideal because it results in this test measuring speed efficiency and ignoring memory efficiency. 
 
diff --git a/include/EASTL/internal/functional_base.h b/include/EASTL/internal/functional_base.h
index 366c1f75..4fe1c3c1 100644
--- a/include/EASTL/internal/functional_base.h
+++ b/include/EASTL/internal/functional_base.h
@@ -360,6 +360,7 @@ namespace eastl
 
 	/// bind1st
 	///
+	EASTL_INTERNAL_DISABLE_DEPRECATED() // unariy_function is deprecated
 	template <typename Operation>
 	class EASTL_REMOVE_AT_2024_APRIL binder1st : public unary_function<typename Operation::second_argument_type, typename Operation::result_type>
 	{
@@ -377,6 +378,7 @@ namespace eastl
 			typename Operation::result_type operator()(typename Operation::second_argument_type& x) const
 				{ return op(value, x); }
 	};
+	EASTL_INTERNAL_RESTORE_DEPRECATED()
 
 
 	EASTL_INTERNAL_DISABLE_DEPRECATED() // 'eastl::binder1st<Operation>': was declared deprecated
@@ -390,6 +392,7 @@ namespace eastl
 
 	/// bind2nd
 	///
+	EASTL_INTERNAL_DISABLE_DEPRECATED() // unariy_function is deprecated
 	template <typename Operation>
 	class EASTL_REMOVE_AT_2024_APRIL binder2nd : public unary_function<typename Operation::first_argument_type, typename Operation::result_type>
 	{
@@ -407,6 +410,7 @@ namespace eastl
 			typename Operation::result_type operator()(typename Operation::first_argument_type& x) const
 				{ return op(x, value); }
 	};
+	EASTL_INTERNAL_RESTORE_DEPRECATED()
 
 
 	EASTL_INTERNAL_DISABLE_DEPRECATED() // 'eastl::binder2nd<Operation>': was declared deprecated
diff --git a/include/EASTL/internal/type_pod.h b/include/EASTL/internal/type_pod.h
index 0cdf5d5f..994bd0a2 100644
--- a/include/EASTL/internal/type_pod.h
+++ b/include/EASTL/internal/type_pod.h
@@ -401,8 +401,14 @@ namespace eastl
 	#define EASTL_DECLARE_TRIVIAL_DESTRUCTOR(T) namespace eastl{ template <> struct EASTL_REMOVE_AT_2024_APRIL has_trivial_destructor<T> : public true_type{}; template <> struct EASTL_REMOVE_AT_2024_APRIL has_trivial_destructor<const T> : public true_type{}; }
 
 	#if EASTL_VARIABLE_TEMPLATES_ENABLED
+	// Note: some compilers (notably GCC) trigger deprecation warnings in template variable
+	// declarations even if the variable is not insantiated here, so turn the warning off
+	// here. If this varialbe is used, the warning will still trigger in the user code, this
+	// just disables the warning in this declaration.
+EASTL_INTERNAL_DISABLE_DEPRECATED()
 		template <class T>
 		EASTL_REMOVE_AT_2024_APRIL EA_CONSTEXPR bool has_trivial_destructor_v = has_trivial_destructor<T>::value;
+EASTL_INTERNAL_RESTORE_DEPRECATED()
     #endif
 
 
@@ -993,7 +999,7 @@ namespace eastl
 	#else
 
 		// If the compiler has this trait built-in (which ideally all compilers would have since it's necessary for full conformance) use it.
-		#if EASTL_COMPILER_INTRINSIC_TYPE_TRAITS_AVAILABLE && ((defined(__clang__) && EA_COMPILER_HAS_FEATURE(is_trivially_constructible)) || defined(EA_COMPILER_MSVC))
+		#if EASTL_COMPILER_INTRINSIC_TYPE_TRAITS_AVAILABLE && ((EASTL_HAS_INTRINSIC(is_trivially_constructible)) || defined(EA_COMPILER_MSVC))
 			#define EASTL_TYPE_TRAIT_is_trivially_constructible_CONFORMANCE 1
 
 			// We have a problem with clang here as of clang 3.4: __is_trivially_constructible(int[]) is false, yet I believe it should be true.
diff --git a/include/EASTL/internal/type_properties.h b/include/EASTL/internal/type_properties.h
index 0ea2fef5..b3e16822 100644
--- a/include/EASTL/internal/type_properties.h
+++ b/include/EASTL/internal/type_properties.h
@@ -376,9 +376,15 @@ namespace eastl
 
 	template<typename> struct EASTL_REMOVE_AT_2024_APRIL result_of;
 
+	// Note: some compilers (notably GCC) trigger deprecation warnings when doing template
+	// specialization if the main template is derpecated, so turn the warning off here. If this
+	// specialization is used, the warning will still trigger in the user code, this just
+	// disables the warning in this declaration.
+EASTL_INTERNAL_DISABLE_DEPRECATED()
 	template<typename F, typename... ArgTypes>
 	struct EASTL_REMOVE_AT_2024_APRIL result_of<F(ArgTypes...)>
 		{ typedef decltype(eastl::declval<F>()(eastl::declval<ArgTypes>()...)) type; };
+EASTL_INTERNAL_RESTORE_DEPRECATED()
 
 
 	// result_of_t is the C++14 using typedef for typename result_of<T>::type.
@@ -386,9 +392,15 @@ namespace eastl
 	#if defined(EA_COMPILER_NO_TEMPLATE_ALIASES)
 		#define EASTL_RESULT_OF_T(T) typename result_of<T>::type
 	#else
+	// Note: some compilers (notably GCC) trigger deprecation warnings in template variable
+	// declarations even if the variable is not insantiated here, so turn the warning off
+	// here. If this varialbe is used, the warning will still trigger in the user code, this
+	// just disables the warning in this declaration.
+EASTL_INTERNAL_DISABLE_DEPRECATED()
 		template <typename T>
 		using result_of_t EASTL_REMOVE_AT_2024_APRIL = typename result_of<T>::type;
 		#define EASTL_RESULT_OF_T(T) result_of_t<T>
+EASTL_INTERNAL_RESTORE_DEPRECATED()
 	#endif
 
 
diff --git a/include/EASTL/iterator.h b/include/EASTL/iterator.h
index a971c872..719615fc 100644
--- a/include/EASTL/iterator.h
+++ b/include/EASTL/iterator.h
@@ -222,6 +222,11 @@ namespace eastl
 	};
 
 
+	// Note: some compilers (notably GCC) trigger deprecation warnings when doing template
+	// specialization if the main template is derpecated, so turn the warning off here. If this
+	// specialization is used, the warning will still trigger in the user code, this just
+	// disables the warning in this declaration.
+EASTL_INTERNAL_DISABLE_DEPRECATED()
 	template <typename Iterator>
 	struct EASTL_REMOVE_AT_2024_SEPT is_iterator_wrapper_helper<Iterator, true>
 	{
@@ -238,6 +243,7 @@ namespace eastl
 	template <typename Iterator>
 	EASTL_REMOVE_AT_2024_SEPT inline typename is_iterator_wrapper_helper<Iterator, eastl::is_iterator_wrapper<Iterator>::value>::iterator_type unwrap_iterator(Iterator it)
 		{ return eastl::is_iterator_wrapper_helper<Iterator, eastl::is_iterator_wrapper<Iterator>::value>::get_unwrapped(it); }
+EASTL_INTERNAL_RESTORE_DEPRECATED()
 
 
 
@@ -424,9 +430,15 @@ namespace eastl
 	struct EASTL_REMOVE_AT_2024_SEPT is_reverse_iterator
 		: public eastl::false_type {};
 
+	// Note: some compilers (notably GCC) trigger deprecation warnings when doing template
+	// specialization if the main template is derpecated, so turn the warning off here. If this
+	// specialization is used, the warning will still trigger in the user code, this just
+	// disables the warning in this declaration.
+EASTL_INTERNAL_DISABLE_DEPRECATED()
 	template<typename Iterator>
 	struct EASTL_REMOVE_AT_2024_SEPT is_reverse_iterator<eastl::reverse_iterator<Iterator>>
 		: public eastl::true_type {};
+EASTL_INTERNAL_RESTORE_DEPRECATED()
 
 	/// unwrap_reverse_iterator is not implemented since there's no
 	/// good use case and there's some abiguitiy. Note that
@@ -642,9 +654,15 @@ namespace eastl
 	struct EASTL_REMOVE_AT_2024_SEPT is_move_iterator
 		: public eastl::false_type {};
 
+	// Note: some compilers (notably GCC) trigger deprecation warnings when doing template
+	// specialization if the main template is derpecated, so turn the warning off here. If this
+	// specialization is used, the warning will still trigger in the user code, this just
+	// disables the warning in this declaration.
+EASTL_INTERNAL_DISABLE_DEPRECATED()
 	template<typename Iterator>
 	struct EASTL_REMOVE_AT_2024_SEPT is_move_iterator<eastl::move_iterator<Iterator>>
 		: public eastl::true_type {};
+EASTL_INTERNAL_RESTORE_DEPRECATED()
 
 
 	/// unwrap_move_iterator
@@ -656,12 +674,14 @@ namespace eastl
 	///      eastl::move_iterator<vector<int>::iterator> moveIterator(intVector.begin());
 	///      vector<int>::iterator it = unwrap_move_iterator(moveIterator);
 	///
+EASTL_INTERNAL_DISABLE_DEPRECATED() // is_iterator_wrapper_helper is deprecated
 	template <typename Iterator>
 	EASTL_REMOVE_AT_2024_SEPT inline typename eastl::is_iterator_wrapper_helper<Iterator, eastl::is_move_iterator<Iterator>::value>::iterator_type unwrap_move_iterator(Iterator it)
 	{
 		// get_unwrapped(it) -> it.unwrap() which is equivalent to `it.base()` for move_iterator and to `it` otherwise.
 		return eastl::is_iterator_wrapper_helper<Iterator, eastl::is_move_iterator<Iterator>::value>::get_unwrapped(it);
 	}
+EASTL_INTERNAL_RESTORE_DEPRECATED()
 
 
 	/// back_insert_iterator
@@ -856,9 +876,15 @@ namespace eastl
 	struct EASTL_REMOVE_AT_2024_SEPT is_insert_iterator
 		: public eastl::false_type {};
 
+	// Note: some compilers (notably GCC) trigger deprecation warnings when doing template
+	// specialization if the main template is derpecated, so turn the warning off here. If this
+	// specialization is used, the warning will still trigger in the user code, this just
+	// disables the warning in this declaration.
+EASTL_INTERNAL_DISABLE_DEPRECATED()
 	template<typename Iterator>
 	struct EASTL_REMOVE_AT_2024_SEPT is_insert_iterator<eastl::insert_iterator<Iterator>>
 		: public eastl::true_type {};
+EASTL_INTERNAL_RESTORE_DEPRECATED()
 
 
 
diff --git a/include/EASTL/memory.h b/include/EASTL/memory.h
index 8660ec77..39309a28 100644
--- a/include/EASTL/memory.h
+++ b/include/EASTL/memory.h
@@ -362,15 +362,15 @@ namespace eastl
 			return *this;
 		}
 
-		raw_storage_iterator<OutputIterator, T>& operator++()
+		raw_storage_iterator& operator++()
 		{
 			++mIterator;
 			return *this;
 		}
 
-		raw_storage_iterator<OutputIterator, T> operator++(int)
+		raw_storage_iterator operator++(int)
 		{
-			raw_storage_iterator<OutputIterator, T> tempIterator = *this;
+			raw_storage_iterator tempIterator = *this;
 			++mIterator;
 			return tempIterator;
 		}
diff --git a/include/EASTL/type_traits.h b/include/EASTL/type_traits.h
index 28eee96f..afc4212d 100644
--- a/include/EASTL/type_traits.h
+++ b/include/EASTL/type_traits.h
@@ -344,6 +344,11 @@ namespace eastl
 	template <bool bCondition, class ConditionIsTrueType, class ConditionIsFalseType>
 	struct EASTL_REMOVE_AT_2024_APRIL type_select { typedef ConditionIsTrueType type; };
 
+	// Note: some compilers (notably GCC) trigger deprecation warnings when doing template
+	// specialization if the main template is derpecated, so turn the warning off here. If this
+	// specialization is used, the warning will still trigger in the user code, this just
+	// disables the warning in this declaration.
+EASTL_INTERNAL_DISABLE_DEPRECATED()
 	template <typename ConditionIsTrueType, class ConditionIsFalseType>
 	struct EASTL_REMOVE_AT_2024_APRIL type_select<false, ConditionIsTrueType, ConditionIsFalseType> { typedef ConditionIsFalseType type; };
 
@@ -351,6 +356,7 @@ namespace eastl
 		template <bool bCondition, class ConditionIsTrueType, class ConditionIsFalseType>
 		using type_select_t EASTL_REMOVE_AT_2024_APRIL = typename type_select<bCondition, ConditionIsTrueType, ConditionIsFalseType>::type;
 	#endif
+EASTL_INTERNAL_RESTORE_DEPRECATED()
 
 
 
@@ -379,8 +385,14 @@ namespace eastl
 	template <bool b1, bool b2, bool b3, bool b4, bool b5>
 	struct EASTL_REMOVE_AT_2024_APRIL type_or { static const bool value = true; };
 
+	// Note: some compilers (notably GCC) trigger deprecation warnings when doing template
+	// specialization if the main template is derpecated, so turn the warning off here. If this
+	// specialization is used, the warning will still trigger in the user code, this just
+	// disables the warning in this declaration.
+EASTL_INTERNAL_DISABLE_DEPRECATED()
 	template <>
 	struct EASTL_REMOVE_AT_2024_APRIL type_or<false, false, false, false, false> { static const bool value = false; };
+EASTL_INTERNAL_RESTORE_DEPRECATED()
 
 
 
@@ -399,8 +411,14 @@ namespace eastl
 	template <bool b1, bool b2, bool b3, bool b4, bool b5>
 	struct EASTL_REMOVE_AT_2024_APRIL type_and{ static const bool value = false; };
 
+	// Note: some compilers (notably GCC) trigger deprecation warnings when doing template
+	// specialization if the main template is derpecated, so turn the warning off here. If this
+	// specialization is used, the warning will still trigger in the user code, this just
+	// disables the warning in this declaration.
+EASTL_INTERNAL_DISABLE_DEPRECATED()
 	template <>
 	struct EASTL_REMOVE_AT_2024_APRIL type_and<true, true, true, true, true>{ static const bool value = true; };
+EASTL_INTERNAL_RESTORE_DEPRECATED()
 
 
 
@@ -436,8 +454,14 @@ namespace eastl
 	template <bool b>
 	struct EASTL_REMOVE_AT_2024_APRIL type_not{ static const bool value = true; };
 
+	// Note: some compilers (notably GCC) trigger deprecation warnings when doing template
+	// specialization if the main template is derpecated, so turn the warning off here. If this
+	// specialization is used, the warning will still trigger in the user code, this just
+	// disables the warning in this declaration.
+EASTL_INTERNAL_DISABLE_DEPRECATED()
 	template <>
 	struct EASTL_REMOVE_AT_2024_APRIL type_not<true>{ static const bool value = false; };
+EASTL_INTERNAL_RESTORE_DEPRECATED()
 
 
 
@@ -576,10 +600,16 @@ namespace eastl
 	template <typename T>
 	struct EASTL_REMOVE_AT_2024_APRIL identity { using type = T; };
 
+	// Note: some compilers (notably GCC) trigger deprecation warnings in template variable
+	// declarations even if the variable is not insantiated here, so turn the warning off
+	// here. If this varialbe is used, the warning will still trigger in the user code, this
+	// just disables the warning in this declaration.
+EASTL_INTERNAL_DISABLE_DEPRECATED()
 	#if EASTL_VARIABLE_TEMPLATES_ENABLED
 		template <typename T>
 		using identity_t EASTL_REMOVE_AT_2024_APRIL = typename identity<T>::type;
 	#endif
+EASTL_INTERNAL_RESTORE_DEPRECATED()
 
 
 	///////////////////////////////////////////////////////////////////////
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 7a13277c..78af0b99 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -77,7 +77,7 @@ target_include_directories(EASTLTest PUBLIC include)
 FetchContent_Declare(
   EABase
   GIT_REPOSITORY https://github.com/electronicarts/EABase.git
-  GIT_TAG        c11d898e3d175c9e957df86e4afe5403429f57f1
+  GIT_TAG        123363eb82e132c0181ac53e43226d8ee76dea12
   GIT_SUBMODULES "" # This should be temporary until we update the cyclic submodule dependencies in EABase.
 )
 FetchContent_MakeAvailable(EABase)