diff --git a/src/plugins/template/tests/functional/op_reference/acos.cpp b/src/plugins/template/tests/functional/op_reference/acos.cpp
index 082d57e512e..a3b51f6150d 100644
--- a/src/plugins/template/tests/functional/op_reference/acos.cpp
+++ b/src/plugins/template/tests/functional/op_reference/acos.cpp
@@ -55,9 +55,9 @@ TEST_P(ReferenceAcosLayerTest, AcosWithHardcodedRefs) {
 INSTANTIATE_TEST_SUITE_P(
     smoke_Acos_With_Hardcoded_Refs, ReferenceAcosLayerTest,
     ::testing::Values(Builder {}
-                          .input({{11}, element::f16, std::vector<ngraph::float16> {-1.f, -0.75f, -0.5f, -0.25f, -0.125f,
+                          .input({{11}, element::f16, std::vector<ov::float16> {-1.f, -0.75f, -0.5f, -0.25f, -0.125f,
                                                                                      0.f, 0.125f, 0.25f, 0.5f, 0.75f, 1.f}})
-                          .expected({{11}, element::f16, std::vector<ngraph::float16> {3.14159265f, 2.41885841f, 2.09439510f, 1.82347658f, 1.69612416f,
+                          .expected({{11}, element::f16, std::vector<ov::float16> {3.14159265f, 2.41885841f, 2.09439510f, 1.82347658f, 1.69612416f,
                                                                                        1.57079633f, 1.44546850f, 1.31811607f, 1.04719755f, 0.72273425f,
                                                                                        0.00000000f}}),
                       Builder {}
diff --git a/src/plugins/template/tests/functional/op_reference/acosh.cpp b/src/plugins/template/tests/functional/op_reference/acosh.cpp
index 5cc071bf0f9..8e2f916655b 100644
--- a/src/plugins/template/tests/functional/op_reference/acosh.cpp
+++ b/src/plugins/template/tests/functional/op_reference/acosh.cpp
@@ -55,8 +55,8 @@ TEST_P(ReferenceAcoshLayerTest, AcoshWithHardcodedRefs) {
 INSTANTIATE_TEST_SUITE_P(
     smoke_Acosh_With_Hardcoded_Refs, ReferenceAcoshLayerTest,
     ::testing::Values(Builder {}
-                          .input({{8}, element::f16, std::vector<ngraph::float16> {1.f, 2.f, 3.f, 4.f, 5.f, 10.f, 100.f, 1000.f}})
-                          .expected({{8}, element::f16, std::vector<ngraph::float16> {0., 1.317, 1.763, 2.063, 2.292, 2.993, 5.298, 7.6012}}),
+                          .input({{8}, element::f16, std::vector<ov::float16> {1.f, 2.f, 3.f, 4.f, 5.f, 10.f, 100.f, 1000.f}})
+                          .expected({{8}, element::f16, std::vector<ov::float16> {0., 1.317, 1.763, 2.063, 2.292, 2.993, 5.298, 7.6012}}),
                       Builder {}
                           .input({{8}, element::f32, std::vector<float> {1.f, 2.f, 3.f, 4.f, 5.f, 10.f, 100.f, 1000.f}})
                           .expected({{8}, element::f32, std::vector<float> {0., 1.317, 1.763, 2.063, 2.292, 2.993, 5.298, 7.6012}}),
diff --git a/src/plugins/template/tests/functional/op_reference/asin.cpp b/src/plugins/template/tests/functional/op_reference/asin.cpp
index 149bcdc152c..362b7fe6acc 100644
--- a/src/plugins/template/tests/functional/op_reference/asin.cpp
+++ b/src/plugins/template/tests/functional/op_reference/asin.cpp
@@ -57,8 +57,8 @@ INSTANTIATE_TEST_SUITE_P(
     smoke_Asin_With_Hardcoded_Refs, ReferenceAsinLayerTest,
     ::testing::Values(
         Builder {}
-            .input({{11}, element::f16, std::vector<ngraph::float16> {-1.f, -0.75f, -0.5f, -0.25f, -0.125f, 0.f, 0.125f, 0.25f, 0.5f, 0.75f, 1.f}})
-            .expected({{11}, element::f16, std::vector<ngraph::float16> {-1.57079633f,
+            .input({{11}, element::f16, std::vector<ov::float16> {-1.f, -0.75f, -0.5f, -0.25f, -0.125f, 0.f, 0.125f, 0.25f, 0.5f, 0.75f, 1.f}})
+            .expected({{11}, element::f16, std::vector<ov::float16> {-1.57079633f,
                             -0.84806208f,
                             -0.52359878f,
                             -0.25268026f,
diff --git a/src/plugins/template/tests/functional/op_reference/asinh.cpp b/src/plugins/template/tests/functional/op_reference/asinh.cpp
index 7292a64bca2..6691662c6df 100644
--- a/src/plugins/template/tests/functional/op_reference/asinh.cpp
+++ b/src/plugins/template/tests/functional/op_reference/asinh.cpp
@@ -57,8 +57,8 @@ INSTANTIATE_TEST_SUITE_P(
     smoke_Asinh_With_Hardcoded_Refs, ReferenceAsinhLayerTest,
     ::testing::Values(
         Builder {}
-            .input({{11}, element::f16, std::vector<ngraph::float16> {0.f, 1.f, -1.f, 2.f, -2.f, 3.f, -3.f, 4.f, 5.f, 10.f, 100.f}})
-            .expected({{11}, element::f16, std::vector<ngraph::float16> {0.00000000f,
+            .input({{11}, element::f16, std::vector<ov::float16> {0.f, 1.f, -1.f, 2.f, -2.f, 3.f, -3.f, 4.f, 5.f, 10.f, 100.f}})
+            .expected({{11}, element::f16, std::vector<ov::float16> {0.00000000f,
                             0.88137359f,
                             -0.88137359f,
                             1.44363548f,
diff --git a/src/plugins/template/tests/functional/op_reference/atan.cpp b/src/plugins/template/tests/functional/op_reference/atan.cpp
index feba9e25878..17e5ca34333 100644
--- a/src/plugins/template/tests/functional/op_reference/atan.cpp
+++ b/src/plugins/template/tests/functional/op_reference/atan.cpp
@@ -56,8 +56,8 @@ INSTANTIATE_TEST_SUITE_P(
     smoke_Atan_With_Hardcoded_Refs, ReferenceAtanLayerTest,
     ::testing::Values(
         Builder{}
-            .input({{11}, element::f16, std::vector<ngraph::float16>{-4.f, -2.f, -1.f, -0.5f, -0.25f, 0.f, 0.25f, 0.5f, 1.f, 2.f, 4.f}})
-            .expected({{11}, element::f16, std::vector<ngraph::float16>{-1.32581766f,
+            .input({{11}, element::f16, std::vector<ov::float16>{-4.f, -2.f, -1.f, -0.5f, -0.25f, 0.f, 0.25f, 0.5f, 1.f, 2.f, 4.f}})
+            .expected({{11}, element::f16, std::vector<ov::float16>{-1.32581766f,
                                                                        -1.10714872f,
                                                                        -0.78539816f,
                                                                        -0.46364761f,
diff --git a/src/plugins/template/tests/functional/op_reference/atanh.cpp b/src/plugins/template/tests/functional/op_reference/atanh.cpp
index 51c94d5eb47..7c019b3b684 100644
--- a/src/plugins/template/tests/functional/op_reference/atanh.cpp
+++ b/src/plugins/template/tests/functional/op_reference/atanh.cpp
@@ -62,10 +62,10 @@ INSTANTIATE_TEST_SUITE_P(
     ReferenceAtanhLayerTest,
     ::testing::Values(
         Builder{}
-            .input({{5}, element::f16, std::vector<ngraph::float16>{-1.0f, -0.5f, 0.0f, 0.8f, 1.0f}})
+            .input({{5}, element::f16, std::vector<ov::float16>{-1.0f, -0.5f, 0.0f, 0.8f, 1.0f}})
             .expected({{5},
                        element::f16,
-                       std::vector<ngraph::float16>{-INFINITY, -0.54930614f, 0.00000000f, 1.0986123f, INFINITY}}),
+                       std::vector<ov::float16>{-INFINITY, -0.54930614f, 0.00000000f, 1.0986123f, INFINITY}}),
         Builder{}
             .input({{5}, element::f32, std::vector<float>{-1.0f, -0.5f, 0.0f, 0.8f, 1.0f}})
             .expected(
diff --git a/src/plugins/template/tests/functional/op_reference/binary_convolution.cpp b/src/plugins/template/tests/functional/op_reference/binary_convolution.cpp
index 2f73d5f2dc0..0516be41267 100644
--- a/src/plugins/template/tests/functional/op_reference/binary_convolution.cpp
+++ b/src/plugins/template/tests/functional/op_reference/binary_convolution.cpp
@@ -4,7 +4,6 @@
 
 #include <gtest/gtest.h>
 
-#include <ngraph_functions/builders.hpp>
 #include "openvino/op/binary_convolution.hpp"
 #include "base_reference_test.hpp"
 #include "openvino/opsets/opset8.hpp"
diff --git a/src/plugins/template/tests/functional/op_reference/comparison.hpp b/src/plugins/template/tests/functional/op_reference/comparison.hpp
index c6cc0826223..16869dcbd2c 100644
--- a/src/plugins/template/tests/functional/op_reference/comparison.hpp
+++ b/src/plugins/template/tests/functional/op_reference/comparison.hpp
@@ -5,15 +5,26 @@
 #include <gtest/gtest.h>
 
 #include "base_reference_test.hpp"
-#include "ngraph_functions/builders.hpp"
+#include "common_test_utils/test_enums.hpp"
+#include "openvino/op/equal.hpp"
+#include "openvino/op/not_equal.hpp"
+#include "openvino/op/greater.hpp"
+#include "openvino/op/greater_eq.hpp"
+#include "openvino/op/less.hpp"
+#include "openvino/op/less_eq.hpp"
+#include "openvino/op/is_inf.hpp"
+#include "openvino/op/is_finite.hpp"
+#include "openvino/op/is_nan.hpp"
 
 using namespace ov;
 
 namespace reference_tests {
 namespace ComparisonOpsRefTestDefinitions {
 
+using ov::test::utils::ComparisonTypes;
+
 struct RefComparisonParams {
-    ngraph::helpers::ComparisonTypes compType;
+    ComparisonTypes compType;
     reference_tests::Tensor input1;
     reference_tests::Tensor input2;
     reference_tests::Tensor expected;
@@ -46,13 +57,54 @@ public:
     }
 
 private:
-    static std::shared_ptr<ov::Model> CreateFunction(ngraph::helpers::ComparisonTypes comp_op_type, const ov::PartialShape& input_shape1,
+    static std::shared_ptr<ov::Model> CreateFunction(ComparisonTypes comp_op_type, const ov::PartialShape& input_shape1,
                                                             const ov::PartialShape& input_shape2, const ov::element::Type& input_type,
                                                             const ov::element::Type& expected_output_type) {
-        const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape1);
-        const auto in2 = std::make_shared<op::v0::Parameter>(input_type, input_shape2);
-        const auto comp = ngraph::builder::makeComparison(in, in2, comp_op_type);
-        return std::make_shared<ov::Model>(ov::NodeVector {comp}, ov::ParameterVector {in, in2});
+        const auto in0 = std::make_shared<op::v0::Parameter>(input_type, input_shape1);
+        const auto in1 = std::make_shared<op::v0::Parameter>(input_type, input_shape2);
+        std::shared_ptr<ov::Node> comp;
+        switch (comp_op_type) {
+        case ComparisonTypes::EQUAL: {
+            comp =  std::make_shared<ov::op::v1::Equal>(in0, in1);
+            break;
+        }
+        case ComparisonTypes::NOT_EQUAL: {
+            comp =  std::make_shared<ov::op::v1::NotEqual>(in0, in1);
+            break;
+        }
+        case ComparisonTypes::GREATER: {
+            comp =  std::make_shared<ov::op::v1::Greater>(in0, in1);
+            break;
+        }
+        case ComparisonTypes::GREATER_EQUAL: {
+            comp =  std::make_shared<ov::op::v1::GreaterEqual>(in0, in1);
+            break;
+        }
+        case ComparisonTypes::IS_FINITE: {
+            comp =  std::make_shared<ov::op::v10::IsFinite>(in0);
+            break;
+        }
+        case ComparisonTypes::IS_INF: {
+            comp =  std::make_shared<ov::op::v10::IsInf>(in0);
+            break;
+        }
+        case ComparisonTypes::IS_NAN: {
+            comp =  std::make_shared<ov::op::v10::IsNaN>(in0);
+            break;
+        }
+        case ComparisonTypes::LESS: {
+            comp =  std::make_shared<ov::op::v1::Less>(in0, in1);
+            break;
+        }
+        case ComparisonTypes::LESS_EQUAL: {
+            comp =  std::make_shared<ov::op::v1::LessEqual>(in0, in1);
+            break;
+        }
+        default: {
+            throw std::runtime_error("Incorrect type of Comparison operation");
+        }
+        }
+        return std::make_shared<ov::Model>(ov::NodeVector {comp}, ov::ParameterVector {in0, in1});
     }
 };
 }  // namespace ComparisonOpsRefTestDefinitions
diff --git a/src/plugins/template/tests/functional/op_reference/conversion.hpp b/src/plugins/template/tests/functional/op_reference/conversion.hpp
index f46f627ab24..0f6b324eb75 100644
--- a/src/plugins/template/tests/functional/op_reference/conversion.hpp
+++ b/src/plugins/template/tests/functional/op_reference/conversion.hpp
@@ -5,25 +5,30 @@
 #include <gtest/gtest.h>
 
 #include "base_reference_test.hpp"
-#include "ngraph_functions/builders.hpp"
+#include "common_test_utils/test_enums.hpp"
+#include "openvino/op/constant.hpp"
+#include "openvino/op/convert.hpp"
+#include "openvino/op/convert_like.hpp"
 
 using namespace ov;
 
 namespace reference_tests {
 namespace ConversionOpsRefTestDefinitions {
 
-static std::map<ngraph::helpers::ConversionTypes, std::string> conversionNames = {
-    {ngraph::helpers::ConversionTypes::CONVERT,      "Convert"},
-    {ngraph::helpers::ConversionTypes::CONVERT_LIKE, "ConvertLike"}
+using ov::test::utils::ConversionTypes;
+
+static std::map<ConversionTypes, std::string> conversionNames = {
+    {ConversionTypes::CONVERT,      "Convert"},
+    {ConversionTypes::CONVERT_LIKE, "ConvertLike"}
 };
 
 struct ConvertParams {
     template <class IT, class OT>
-    ConvertParams(ngraph::helpers::ConversionTypes convType, const ov::PartialShape& shape, const ov::element::Type& iType,
+    ConvertParams(ConversionTypes convType, const ov::PartialShape& shape, const ov::element::Type& iType,
                   const ov::element::Type& oType, const std::vector<IT>& iValues, const std::vector<OT>& oValues, size_t iSize = 0, size_t oSize = 0)
         : conversionType(convType), pshape(shape), inType(iType), outType(oType), inputData(CreateTensor(iType, iValues, iSize)),
           refData(CreateTensor(oType, oValues, oSize)) {}
-    ngraph::helpers::ConversionTypes conversionType;
+    ConversionTypes conversionType;
     ov::PartialShape pshape;
     ov::element::Type inType;
     ov::element::Type outType;
@@ -53,9 +58,17 @@ public:
 private:
     static std::shared_ptr<ov::Model> CreateFunction(const ov::PartialShape& input_shape, const ov::element::Type& input_type,
                                                         const ov::element::Type& expected_output_type,
-                                                        const ngraph::helpers::ConversionTypes& conversion_type) {
+                                                        const ConversionTypes& conversion_type) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
-        const auto convert = ngraph::builder::makeConversion(in, expected_output_type, conversion_type);
+        std::shared_ptr<ov::Node> convert;
+        if (conversion_type == ConversionTypes::CONVERT) {
+            convert = std::make_shared<ov::op::v0::Convert>(in, expected_output_type);
+        } else if (conversion_type == ConversionTypes::CONVERT_LIKE) {
+            const auto like = std::make_shared<ov::op::v0::Constant>(expected_output_type, ov::Shape{1});
+            convert = std::make_shared<ov::op::v1::ConvertLike>(in, like);
+        } else {
+            throw std::runtime_error("Incorrect type of Conversion operation");
+        }
         return std::make_shared<ov::Model>(ov::NodeVector {convert}, ov::ParameterVector {in});
     }
 };
diff --git a/src/plugins/template/tests/functional/op_reference/convert.cpp b/src/plugins/template/tests/functional/op_reference/convert.cpp
index 70e0b9f29df..61eb58ecb40 100644
--- a/src/plugins/template/tests/functional/op_reference/convert.cpp
+++ b/src/plugins/template/tests/functional/op_reference/convert.cpp
@@ -9,7 +9,6 @@
 #include "conversion.hpp"
 
 using namespace ov;
-using ConversionTypes = ngraph::helpers::ConversionTypes;
 
 namespace reference_tests {
 namespace ConversionOpsRefTestDefinitions {
@@ -101,9 +100,9 @@ INSTANTIATE_TEST_SUITE_P(
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::i4, std::vector<int64_t> {-1, -2, 2, 3},
                       std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::i4,
-                      std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
+                      std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::i4,
-                      std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
+                      std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::i4, std::vector<float> {-1, -2, 2, 3},
                       std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
         // destination i8
@@ -130,9 +129,9 @@ INSTANTIATE_TEST_SUITE_P(
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::i8, std::vector<int64_t> {-1, -2, 2, 3},
                       std::vector<int8_t> {-1, -2, 2, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::i8,
-                      std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<int8_t> {-1, -2, 0, 3}),
+                      std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<int8_t> {-1, -2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::i8,
-                      std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<int8_t> {-1, -2, 0, 3}),
+                      std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<int8_t> {-1, -2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::i8, std::vector<float> {-1, -2, 2.2, 3.8},
                       std::vector<int8_t> {-1, -2, 2, 3}),
         // destination i16
@@ -159,9 +158,9 @@ INSTANTIATE_TEST_SUITE_P(
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::i16, std::vector<int64_t> {-1, -2, 2, 3},
                       std::vector<int16_t> {-1, -2, 2, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::i16,
-                      std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<int16_t> {-1, -2, 0, 3}),
+                      std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<int16_t> {-1, -2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::i16,
-                      std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<int16_t> {-1, -2, 0, 3}),
+                      std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<int16_t> {-1, -2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::i16, std::vector<float> {-1, -2, 2.2, 3.8},
                       std::vector<int16_t> {-1, -2, 2, 3}),
         // destination i32
@@ -188,9 +187,9 @@ INSTANTIATE_TEST_SUITE_P(
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::i32, std::vector<int64_t> {-1, -2, 2, 3},
                       std::vector<int32_t> {-1, -2, 2, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::i32,
-                      std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<int32_t> {-1, -2, 0, 3}),
+                      std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<int32_t> {-1, -2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::i32,
-                      std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<int32_t> {-1, -2, 0, 3}),
+                      std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<int32_t> {-1, -2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::i32, std::vector<float> {-1, -2, 2.2, 3.8},
                       std::vector<int32_t> {-1, -2, 2, 3}),
         // destination i64
@@ -217,9 +216,9 @@ INSTANTIATE_TEST_SUITE_P(
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::i64, std::vector<int64_t> {-1, -2, 2, 3},
                       std::vector<int64_t> {-1, -2, 2, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::i64,
-                      std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<int64_t> {-1, -2, 0, 3}),
+                      std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<int64_t> {-1, -2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::i64,
-                      std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<int64_t> {-1, -2, 0, 3}),
+                      std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<int64_t> {-1, -2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::i64, std::vector<float> {-1, -2, 2.2, 3.8},
                       std::vector<int64_t> {-1, -2, 2, 3}),
 
@@ -247,9 +246,9 @@ INSTANTIATE_TEST_SUITE_P(
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::i64, ov::element::u1,
                       std::vector<int64_t> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::f16, ov::element::u1,
-                      std::vector<ngraph::float16> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
+                      std::vector<ov::float16> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::bf16, ov::element::u1,
-                      std::vector<ngraph::bfloat16> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
+                      std::vector<ov::bfloat16> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::f32, ov::element::u1,
                       std::vector<float> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
 
@@ -277,9 +276,9 @@ INSTANTIATE_TEST_SUITE_P(
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::u4, std::vector<int64_t> {-1, -2, 2, 3},
                       std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::u4,
-                      std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
+                      std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::u4,
-                      std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
+                      std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::u4, std::vector<float> {-1, -2, 2, 3},
                       std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
 
@@ -306,10 +305,10 @@ INSTANTIATE_TEST_SUITE_P(
                       std::vector<uint8_t> {1, 2, 2, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::u8, std::vector<int64_t> {1, 2, 2, 3},
                       std::vector<uint8_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::u8, std::vector<ngraph::float16> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::u8, std::vector<ov::float16> {1, 2, 0, 3},
                       std::vector<uint8_t> {1, 2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::u8,
-                      std::vector<ngraph::bfloat16> {1, 2, 0, 3}, std::vector<uint8_t> {1, 2, 0, 3}),
+                      std::vector<ov::bfloat16> {1, 2, 0, 3}, std::vector<uint8_t> {1, 2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::u8, std::vector<float> {1, 2, 2.2, 3.8},
                       std::vector<uint8_t> {1, 2, 2, 3}),
 
@@ -336,10 +335,10 @@ INSTANTIATE_TEST_SUITE_P(
                       std::vector<uint16_t> {1, 2, 2, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::u16, std::vector<int64_t> {1, 2, 2, 3},
                       std::vector<uint16_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::u16, std::vector<ngraph::float16> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::u16, std::vector<ov::float16> {1, 2, 0, 3},
                       std::vector<uint16_t> {1, 2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::u16,
-                      std::vector<ngraph::bfloat16> {1, 2, 0, 3}, std::vector<uint16_t> {1, 2, 0, 3}),
+                      std::vector<ov::bfloat16> {1, 2, 0, 3}, std::vector<uint16_t> {1, 2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::u16, std::vector<float> {1, 2, 2.2, 3.8},
                       std::vector<uint16_t> {1, 2, 2, 3}),
 
@@ -366,10 +365,10 @@ INSTANTIATE_TEST_SUITE_P(
                       std::vector<uint32_t> {1, 2, 2, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::u32, std::vector<int64_t> {1, 2, 2, 3},
                       std::vector<uint32_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::u32, std::vector<ngraph::float16> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::u32, std::vector<ov::float16> {1, 2, 0, 3},
                       std::vector<uint32_t> {1, 2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::u32,
-                      std::vector<ngraph::bfloat16> {1, 2, 0, 3}, std::vector<uint32_t> {1, 2, 0, 3}),
+                      std::vector<ov::bfloat16> {1, 2, 0, 3}, std::vector<uint32_t> {1, 2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::u32, std::vector<float> {1, 2, 2.2, 3.8},
                       std::vector<uint32_t> {1, 2, 2, 3}),
         // destination u64
@@ -395,10 +394,10 @@ INSTANTIATE_TEST_SUITE_P(
                       std::vector<uint64_t> {1, 2, 2, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i64, ov::element::u64, std::vector<int64_t> {1, 2, 2, 3},
                       std::vector<uint64_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::u64, std::vector<ngraph::float16> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f16, ov::element::u64, std::vector<ov::float16> {1, 2, 0, 3},
                       std::vector<uint64_t> {1, 2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::bf16, ov::element::u64,
-                      std::vector<ngraph::bfloat16> {1, 2, 0, 3}, std::vector<uint64_t> {1, 2, 0, 3}),
+                      std::vector<ov::bfloat16> {1, 2, 0, 3}, std::vector<uint64_t> {1, 2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::u64, std::vector<float> {1, 2, 2.2, 3.8},
                       std::vector<uint64_t> {1, 2, 2, 3})),
     ReferenceConversionLayerTest::getTestCaseName);
diff --git a/src/plugins/template/tests/functional/op_reference/convert_like.cpp b/src/plugins/template/tests/functional/op_reference/convert_like.cpp
index ecab168e386..3ff098e4e14 100644
--- a/src/plugins/template/tests/functional/op_reference/convert_like.cpp
+++ b/src/plugins/template/tests/functional/op_reference/convert_like.cpp
@@ -8,7 +8,6 @@
 #include "conversion.hpp"
 
 using namespace ov;
-using ConversionTypes = ngraph::helpers::ConversionTypes;
 
 namespace reference_tests {
 namespace ConversionOpsRefTestDefinitions {
@@ -101,9 +100,9 @@ INSTANTIATE_TEST_SUITE_P(
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::i4, std::vector<int64_t> {-1, -2, 2, 3},
                       std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::i4,
-                      std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
+                      std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::i4,
-                      std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
+                      std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::i4, std::vector<float> {-1, -2, 2, 3},
                       std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
         // destination i8
@@ -130,9 +129,9 @@ INSTANTIATE_TEST_SUITE_P(
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::i8, std::vector<int64_t> {-1, -2, 2, 3},
                       std::vector<int8_t> {-1, -2, 2, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::i8,
-                      std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<int8_t> {-1, -2, 0, 3}),
+                      std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<int8_t> {-1, -2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::i8,
-                      std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<int8_t> {-1, -2, 0, 3}),
+                      std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<int8_t> {-1, -2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::i8, std::vector<float> {-1, -2, 2, 3},
                       std::vector<int8_t> {-1, -2, 2, 3}),
         // destination i16
@@ -159,9 +158,9 @@ INSTANTIATE_TEST_SUITE_P(
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::i16, std::vector<int64_t> {-1, -2, 2, 3},
                       std::vector<int16_t> {-1, -2, 2, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::i16,
-                      std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<int16_t> {-1, -2, 0, 3}),
+                      std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<int16_t> {-1, -2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::i16,
-                      std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<int16_t> {-1, -2, 0, 3}),
+                      std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<int16_t> {-1, -2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::i16, std::vector<float> {-1, -2, 2, 3},
                       std::vector<int16_t> {-1, -2, 2, 3}),
         // destination i32
@@ -188,9 +187,9 @@ INSTANTIATE_TEST_SUITE_P(
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::i32, std::vector<int64_t> {-1, -2, 2, 3},
                       std::vector<int32_t> {-1, -2, 2, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::i32,
-                      std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<int32_t> {-1, -2, 0, 3}),
+                      std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<int32_t> {-1, -2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::i32,
-                      std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<int32_t> {-1, -2, 0, 3}),
+                      std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<int32_t> {-1, -2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::i32, std::vector<float> {-1, -2, 2, 3},
                       std::vector<int32_t> {-1, -2, 2, 3}),
         // destination i64
@@ -217,9 +216,9 @@ INSTANTIATE_TEST_SUITE_P(
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::i64, std::vector<int64_t> {-1, -2, 2, 3},
                       std::vector<int64_t> {-1, -2, 2, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::i64,
-                      std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<int64_t> {-1, -2, 0, 3}),
+                      std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<int64_t> {-1, -2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::i64,
-                      std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<int64_t> {-1, -2, 0, 3}),
+                      std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<int64_t> {-1, -2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::i64, std::vector<float> {-1, -2, 2, 3},
                       std::vector<int64_t> {-1, -2, 2, 3}),
 
@@ -247,9 +246,9 @@ INSTANTIATE_TEST_SUITE_P(
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::i64, ov::element::u1,
                       std::vector<int64_t> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::f16, ov::element::u1,
-                      std::vector<ngraph::float16> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
+                      std::vector<ov::float16> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::bf16, ov::element::u1,
-                      std::vector<ngraph::bfloat16> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
+                      std::vector<ov::bfloat16> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::f32, ov::element::u1,
                       std::vector<float> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
 
@@ -277,9 +276,9 @@ INSTANTIATE_TEST_SUITE_P(
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::u4, std::vector<int64_t> {-1, -2, 2, 3},
                       std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::u4,
-                      std::vector<ngraph::float16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
+                      std::vector<ov::float16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::u4,
-                      std::vector<ngraph::bfloat16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
+                      std::vector<ov::bfloat16> {-1, -2, 0, 3}, std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::u4, std::vector<float> {-1, -2, 2, 3},
                       std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
 
@@ -307,9 +306,9 @@ INSTANTIATE_TEST_SUITE_P(
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::u8, std::vector<int64_t> {1, 2, 2, 3},
                       std::vector<uint8_t> {1, 2, 2, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::u8,
-                      std::vector<ngraph::float16> {1, 2, 0, 3}, std::vector<uint8_t> {1, 2, 0, 3}),
+                      std::vector<ov::float16> {1, 2, 0, 3}, std::vector<uint8_t> {1, 2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::u8,
-                      std::vector<ngraph::bfloat16> {1, 2, 0, 3}, std::vector<uint8_t> {1, 2, 0, 3}),
+                      std::vector<ov::bfloat16> {1, 2, 0, 3}, std::vector<uint8_t> {1, 2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::u8, std::vector<float> {1, 2, 2, 3},
                       std::vector<uint8_t> {1, 2, 2, 3}),
 
@@ -337,9 +336,9 @@ INSTANTIATE_TEST_SUITE_P(
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::u16, std::vector<int64_t> {1, 2, 2, 3},
                       std::vector<uint16_t> {1, 2, 2, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::u16,
-                      std::vector<ngraph::float16> {1, 2, 0, 3}, std::vector<uint16_t> {1, 2, 0, 3}),
+                      std::vector<ov::float16> {1, 2, 0, 3}, std::vector<uint16_t> {1, 2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::u16,
-                      std::vector<ngraph::bfloat16> {1, 2, 0, 3}, std::vector<uint16_t> {1, 2, 0, 3}),
+                      std::vector<ov::bfloat16> {1, 2, 0, 3}, std::vector<uint16_t> {1, 2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::u16, std::vector<float> {1, 2, 2, 3},
                       std::vector<uint16_t> {1, 2, 2, 3}),
 
@@ -367,9 +366,9 @@ INSTANTIATE_TEST_SUITE_P(
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::u32, std::vector<int64_t> {1, 2, 2, 3},
                       std::vector<uint32_t> {1, 2, 2, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::u32,
-                      std::vector<ngraph::float16> {1, 2, 0, 3}, std::vector<uint32_t> {1, 2, 0, 3}),
+                      std::vector<ov::float16> {1, 2, 0, 3}, std::vector<uint32_t> {1, 2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::u32,
-                      std::vector<ngraph::bfloat16> {1, 2, 0, 3}, std::vector<uint32_t> {1, 2, 0, 3}),
+                      std::vector<ov::bfloat16> {1, 2, 0, 3}, std::vector<uint32_t> {1, 2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::u32, std::vector<float> {1, 2, 2, 3},
                       std::vector<uint32_t> {1, 2, 2, 3}),
         // destination u64
@@ -396,9 +395,9 @@ INSTANTIATE_TEST_SUITE_P(
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i64, ov::element::u64, std::vector<int64_t> {1, 2, 2, 3},
                       std::vector<uint64_t> {1, 2, 2, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f16, ov::element::u64,
-                      std::vector<ngraph::float16> {1, 2, 0, 3}, std::vector<uint64_t> {1, 2, 0, 3}),
+                      std::vector<ov::float16> {1, 2, 0, 3}, std::vector<uint64_t> {1, 2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::bf16, ov::element::u64,
-                      std::vector<ngraph::bfloat16> {1, 2, 0, 3}, std::vector<uint64_t> {1, 2, 0, 3}),
+                      std::vector<ov::bfloat16> {1, 2, 0, 3}, std::vector<uint64_t> {1, 2, 0, 3}),
         ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::f32, ov::element::u64, std::vector<float> {1, 2, 2, 3},
                       std::vector<uint64_t> {1, 2, 2, 3})),
     ReferenceConversionLayerTest::getTestCaseName);
diff --git a/src/plugins/template/tests/functional/op_reference/cos.cpp b/src/plugins/template/tests/functional/op_reference/cos.cpp
index c39038ad5bc..ed8fab2e027 100644
--- a/src/plugins/template/tests/functional/op_reference/cos.cpp
+++ b/src/plugins/template/tests/functional/op_reference/cos.cpp
@@ -56,8 +56,8 @@ INSTANTIATE_TEST_SUITE_P(
     smoke_Cos_With_Hardcoded_Refs, ReferenceCosLayerTest,
     ::testing::Values(
         Builder {}
-            .input({{11}, element::f16, std::vector<ngraph::float16> {0.f, 0.25f, -0.25f, 0.5f, -0.5f, 1.f, -1.f, 2.f, -2.f, 4.f, -4.f}})
-            .expected({{11}, element::f16, std::vector<ngraph::float16> {1.00000000f,
+            .input({{11}, element::f16, std::vector<ov::float16> {0.f, 0.25f, -0.25f, 0.5f, -0.5f, 1.f, -1.f, 2.f, -2.f, 4.f, -4.f}})
+            .expected({{11}, element::f16, std::vector<ov::float16> {1.00000000f,
                                           0.96891242f,
                                           0.96891242f,
                                           0.87758256f,
diff --git a/src/plugins/template/tests/functional/op_reference/cosh.cpp b/src/plugins/template/tests/functional/op_reference/cosh.cpp
index 8043da626a9..55280c7fc23 100644
--- a/src/plugins/template/tests/functional/op_reference/cosh.cpp
+++ b/src/plugins/template/tests/functional/op_reference/cosh.cpp
@@ -56,8 +56,8 @@ INSTANTIATE_TEST_SUITE_P(
     smoke_Cosh_With_Hardcoded_Refs, ReferenceCoshLayerTest,
     ::testing::Values(
         Builder {}
-            .input({{11}, element::f16, std::vector<ngraph::float16> {-4.f, -2.f, -1.f, -0.5f, -0.25f, 0.f, 0.25f, 0.5f, 1.f, 2.f, 4.f}})
-            .expected({{11}, element::f16, std::vector<ngraph::float16> {27.30823284f,
+            .input({{11}, element::f16, std::vector<ov::float16> {-4.f, -2.f, -1.f, -0.5f, -0.25f, 0.f, 0.25f, 0.5f, 1.f, 2.f, 4.f}})
+            .expected({{11}, element::f16, std::vector<ov::float16> {27.30823284f,
                             3.76219569f,
                             1.54308063f,
                             1.12762597f,
diff --git a/src/plugins/template/tests/functional/op_reference/embedding_segments_sum.cpp b/src/plugins/template/tests/functional/op_reference/embedding_segments_sum.cpp
index 3f842b68199..1097aa85620 100644
--- a/src/plugins/template/tests/functional/op_reference/embedding_segments_sum.cpp
+++ b/src/plugins/template/tests/functional/op_reference/embedding_segments_sum.cpp
@@ -20,11 +20,11 @@ struct EmbeddingSegmentsSumParams {
                                const ov::PartialShape& oShape,
                                const ov::element::Type& oType,
                                const std::vector<IT>& oValues,
-                               const std::shared_ptr<ngraph::opset1::Constant>& indices,
-                               const std::shared_ptr<ngraph::opset1::Constant>& segment_ids,
-                               const std::shared_ptr<ngraph::opset1::Constant>& num_segments,
-                               const std::shared_ptr<ngraph::opset1::Constant>& default_index = nullptr,
-                               const std::shared_ptr<ngraph::opset1::Constant>& per_sample_weights = nullptr)
+                               const std::shared_ptr<ov::op::v0::Constant>& indices,
+                               const std::shared_ptr<ov::op::v0::Constant>& segment_ids,
+                               const std::shared_ptr<ov::op::v0::Constant>& num_segments,
+                               const std::shared_ptr<ov::op::v0::Constant>& default_index = nullptr,
+                               const std::shared_ptr<ov::op::v0::Constant>& per_sample_weights = nullptr)
         : _iShape(iShape),
           _iType(iType),
           _iData(CreateTensor(iType, iValues)),
@@ -46,11 +46,11 @@ struct EmbeddingSegmentsSumParams {
     ov::element::Type _refType;
     ov::Tensor _refData;
 
-    std::shared_ptr<ngraph::opset1::Constant> _indices;
-    std::shared_ptr<ngraph::opset1::Constant> _segmentIds;
-    std::shared_ptr<ngraph::opset1::Constant> _numSegments;
-    std::shared_ptr<ngraph::opset1::Constant> _defaultIndex;      // Optional, default filled zero.
-    std::shared_ptr<ngraph::opset1::Constant> _perSampleWeights;  // Optional, default is tensor of ones.
+    std::shared_ptr<ov::op::v0::Constant> _indices;
+    std::shared_ptr<ov::op::v0::Constant> _segmentIds;
+    std::shared_ptr<ov::op::v0::Constant> _numSegments;
+    std::shared_ptr<ov::op::v0::Constant> _defaultIndex;      // Optional, default filled zero.
+    std::shared_ptr<ov::op::v0::Constant> _perSampleWeights;  // Optional, default is tensor of ones.
 };
 
 class ReferenceEmbeddingSegmentsSumLayerTest : public testing::TestWithParam<EmbeddingSegmentsSumParams>,
@@ -82,11 +82,11 @@ private:
     static std::shared_ptr<Model> CreateFunction(
         const PartialShape& input_shape,
         const element::Type& input_type,
-        const std::shared_ptr<ngraph::opset1::Constant> indices,
-        const std::shared_ptr<ngraph::opset1::Constant> segment_ids,
-        const std::shared_ptr<ngraph::opset1::Constant> num_segments,
-        const std::shared_ptr<ngraph::opset1::Constant> default_index,
-        const std::shared_ptr<ngraph::opset1::Constant> per_sample_weights) {
+        const std::shared_ptr<ov::op::v0::Constant> indices,
+        const std::shared_ptr<ov::op::v0::Constant> segment_ids,
+        const std::shared_ptr<ov::op::v0::Constant> num_segments,
+        const std::shared_ptr<ov::op::v0::Constant> default_index,
+        const std::shared_ptr<ov::op::v0::Constant> per_sample_weights) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
 
         if (default_index) {
@@ -128,11 +128,11 @@ INSTANTIATE_TEST_SUITE_P(
             ov::PartialShape{3, 2},
             ov::element::f32,
             {-1.05f, -1.2f, -0.2f, -0.6f, -0.1f, 0.4f},
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 0, 2, 2}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{3}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0}),
-            std::make_shared<ngraph::opset1::Constant>(element::f32,
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 0, 2, 2}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{3}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0}),
+            std::make_shared<ov::op::v0::Constant>(element::f32,
                                                        ov::Shape({4}),
                                                        std::vector<float>{0.5, 0.5, 0.5, 0.5})),
         EmbeddingSegmentsSumParams(
@@ -142,10 +142,10 @@ INSTANTIATE_TEST_SUITE_P(
             ov::PartialShape{3, 2},
             ov::element::f64,
             std::vector<double>{-2.1, -2.4, -0.2, -0.6, -0.2, 0.8},
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 0, 2, 2}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{3}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0})),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 0, 2, 2}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{3}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0})),
         EmbeddingSegmentsSumParams(
             ov::PartialShape{5, 2},
             ov::element::i32,
@@ -153,9 +153,9 @@ INSTANTIATE_TEST_SUITE_P(
             ov::PartialShape{3, 2},
             ov::element::i32,
             std::vector<int32_t>{-6, -4, 0, 0, 2, 18},
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 0, 2, 2}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{3})),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 0, 2, 2}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{3})),
         EmbeddingSegmentsSumParams(
             ov::PartialShape{5, 2},
             ov::element::u32,
@@ -163,10 +163,10 @@ INSTANTIATE_TEST_SUITE_P(
             ov::PartialShape{3, 2},
             ov::element::u32,
             std::vector<uint32_t>{6, 8, 3, 4, 16, 18},
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 0, 2, 2}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{3}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{1})),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 0, 2, 2}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{3}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{1})),
         EmbeddingSegmentsSumParams(
             ov::PartialShape{5, 2},
             ov::element::f16,
@@ -174,9 +174,9 @@ INSTANTIATE_TEST_SUITE_P(
             ov::PartialShape{3, 2},
             ov::element::f16,
             std::vector<float16>{-2.1, -2.4, 0, 0, -0.2, 0.8},
-            std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}),
-            std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 0, 2, 2}),
-            std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{3})),
+            std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}),
+            std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 0, 2, 2}),
+            std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{3})),
         EmbeddingSegmentsSumParams(
             ov::PartialShape{5, 2},
             ov::element::i64,
@@ -184,10 +184,10 @@ INSTANTIATE_TEST_SUITE_P(
             ov::PartialShape{3, 2},
             ov::element::i64,
             std::vector<int64_t>{-6, -4, -1, 2, 2, 18},
-            std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}),
-            std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 0, 2, 2}),
-            std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{3}),
-            std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{0})),
+            std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}),
+            std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 0, 2, 2}),
+            std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{3}),
+            std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{0})),
         EmbeddingSegmentsSumParams(
             ov::PartialShape{5, 2},
             ov::element::i8,
@@ -195,11 +195,11 @@ INSTANTIATE_TEST_SUITE_P(
             ov::PartialShape{3, 2},
             ov::element::i8,
             std::vector<int8_t>{-12, -8, -1, 2, 4, 36},
-            std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}),
-            std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 0, 2, 2}),
-            std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{3}),
-            std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{0}),
-            std::make_shared<ngraph::opset1::Constant>(element::i8, ov::Shape({4}), std::vector<int8_t>{2, 2, 2, 2})),
+            std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}),
+            std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 0, 2, 2}),
+            std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{3}),
+            std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{0}),
+            std::make_shared<ov::op::v0::Constant>(element::i8, ov::Shape({4}), std::vector<int8_t>{2, 2, 2, 2})),
         EmbeddingSegmentsSumParams(
             ov::PartialShape{5, 2},
             ov::element::u8,
@@ -207,8 +207,8 @@ INSTANTIATE_TEST_SUITE_P(
             ov::PartialShape{3, 2},
             ov::element::u8,
             std::vector<uint8_t>{6, 8, 1, 2, 16, 18},
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 0, 2, 2}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{3}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0}))),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 0, 2, 2}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{3}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0}))),
     ReferenceEmbeddingSegmentsSumLayerTest::getTestCaseName);
diff --git a/src/plugins/template/tests/functional/op_reference/embeddingbag_offsetssum.cpp b/src/plugins/template/tests/functional/op_reference/embeddingbag_offsetssum.cpp
index 908c95d61b9..d4d7c5c492c 100644
--- a/src/plugins/template/tests/functional/op_reference/embeddingbag_offsetssum.cpp
+++ b/src/plugins/template/tests/functional/op_reference/embeddingbag_offsetssum.cpp
@@ -20,10 +20,10 @@ struct EmbeddingBagOffsetsSumParams {
                                  const ov::PartialShape& oShape,
                                  const ov::element::Type& oType,
                                  const std::vector<IT>& oValues,
-                                 const std::shared_ptr<ngraph::opset1::Constant>& indices,
-                                 const std::shared_ptr<ngraph::opset1::Constant>& offsets,
-                                 const std::shared_ptr<ngraph::opset1::Constant>& default_index = nullptr,
-                                 const std::shared_ptr<ngraph::opset1::Constant>& per_sample_weights = nullptr)
+                                 const std::shared_ptr<ov::op::v0::Constant>& indices,
+                                 const std::shared_ptr<ov::op::v0::Constant>& offsets,
+                                 const std::shared_ptr<ov::op::v0::Constant>& default_index = nullptr,
+                                 const std::shared_ptr<ov::op::v0::Constant>& per_sample_weights = nullptr)
         : _iShape(iShape),
           _iType(iType),
           _iData(CreateTensor(iType, iValues)),
@@ -43,10 +43,10 @@ struct EmbeddingBagOffsetsSumParams {
     ov::element::Type _refType;
     ov::Tensor _refData;
 
-    std::shared_ptr<ngraph::opset1::Constant> _indices;
-    std::shared_ptr<ngraph::opset1::Constant> _offsets;
-    std::shared_ptr<ngraph::opset1::Constant> _defaultIndex;      // Optional, default filled zero.
-    std::shared_ptr<ngraph::opset1::Constant> _perSampleWeights;  // Optional, default is tensor of ones.
+    std::shared_ptr<ov::op::v0::Constant> _indices;
+    std::shared_ptr<ov::op::v0::Constant> _offsets;
+    std::shared_ptr<ov::op::v0::Constant> _defaultIndex;      // Optional, default filled zero.
+    std::shared_ptr<ov::op::v0::Constant> _perSampleWeights;  // Optional, default is tensor of ones.
 };
 
 class ReferenceEmbeddingBagOffsetsSumLayerTest : public testing::TestWithParam<EmbeddingBagOffsetsSumParams>,
@@ -77,10 +77,10 @@ private:
     static std::shared_ptr<ov::Model> CreateFunction(
         const PartialShape& input_shape,
         const element::Type& input_type,
-        const std::shared_ptr<ngraph::opset1::Constant> indices,
-        const std::shared_ptr<ngraph::opset1::Constant> offsets,
-        const std::shared_ptr<ngraph::opset1::Constant> default_index,
-        const std::shared_ptr<ngraph::opset1::Constant> per_sample_weights) {
+        const std::shared_ptr<ov::op::v0::Constant> indices,
+        const std::shared_ptr<ov::op::v0::Constant> offsets,
+        const std::shared_ptr<ov::op::v0::Constant> default_index,
+        const std::shared_ptr<ov::op::v0::Constant> per_sample_weights) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
 
         if (default_index) {
@@ -117,10 +117,10 @@ INSTANTIATE_TEST_SUITE_P(
             ov::PartialShape{3, 2},
             ov::element::f32,
             {-1.05f, -1.2f, -0.2f, -0.6f, -0.1f, 0.4f},
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({3}), std::vector<int32_t>{0, 2, 2}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0}),
-            std::make_shared<ngraph::opset1::Constant>(element::f32,
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({3}), std::vector<int32_t>{0, 2, 2}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0}),
+            std::make_shared<ov::op::v0::Constant>(element::f32,
                                                        ov::Shape({4}),
                                                        std::vector<float>{0.5, 0.5, 0.5, 0.5})),
         EmbeddingBagOffsetsSumParams(
@@ -130,9 +130,9 @@ INSTANTIATE_TEST_SUITE_P(
             ov::PartialShape{3, 2},
             ov::element::f64,
             std::vector<double>{-2.1, -2.4, -0.2, -0.6, -0.2, 0.8},
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({3}), std::vector<int32_t>{0, 2, 2}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0})),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({3}), std::vector<int32_t>{0, 2, 2}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0})),
         EmbeddingBagOffsetsSumParams(
             ov::PartialShape{5, 2},
             ov::element::i32,
@@ -140,8 +140,8 @@ INSTANTIATE_TEST_SUITE_P(
             ov::PartialShape{3, 2},
             ov::element::i32,
             std::vector<int32_t>{-6, -4, 0, 0, 2, 18},
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({3}), std::vector<int32_t>{0, 2, 2})),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({3}), std::vector<int32_t>{0, 2, 2})),
         EmbeddingBagOffsetsSumParams(
             ov::PartialShape{5, 2},
             ov::element::u32,
@@ -149,9 +149,9 @@ INSTANTIATE_TEST_SUITE_P(
             ov::PartialShape{3, 2},
             ov::element::u32,
             std::vector<uint32_t>{6, 8, 3, 4, 16, 18},
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({3}), std::vector<int32_t>{0, 2, 2}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{1})),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({3}), std::vector<int32_t>{0, 2, 2}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{1})),
         EmbeddingBagOffsetsSumParams(
             ov::PartialShape{5, 2},
             ov::element::f16,
@@ -159,8 +159,8 @@ INSTANTIATE_TEST_SUITE_P(
             ov::PartialShape{3, 2},
             ov::element::f16,
             std::vector<float16>{-2.1, -2.4, 0, 0, -0.2, 0.8},
-            std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}),
-            std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({3}), std::vector<int64_t>{0, 2, 2})),
+            std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}),
+            std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({3}), std::vector<int64_t>{0, 2, 2})),
         EmbeddingBagOffsetsSumParams(
             ov::PartialShape{5, 2},
             ov::element::i64,
@@ -168,9 +168,9 @@ INSTANTIATE_TEST_SUITE_P(
             ov::PartialShape{3, 2},
             ov::element::i64,
             std::vector<int64_t>{-6, -4, -1, 2, 2, 18},
-            std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}),
-            std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({3}), std::vector<int64_t>{0, 2, 2}),
-            std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{0})),
+            std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}),
+            std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({3}), std::vector<int64_t>{0, 2, 2}),
+            std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{0})),
         EmbeddingBagOffsetsSumParams(
             ov::PartialShape{5, 2},
             ov::element::i8,
@@ -178,10 +178,10 @@ INSTANTIATE_TEST_SUITE_P(
             ov::PartialShape{3, 2},
             ov::element::i8,
             std::vector<int8_t>{-12, -8, -1, 2, 4, 36},
-            std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}),
-            std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape({3}), std::vector<int64_t>{0, 2, 2}),
-            std::make_shared<ngraph::opset1::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{0}),
-            std::make_shared<ngraph::opset1::Constant>(element::i8, ov::Shape({4}), std::vector<int8_t>{2, 2, 2, 2})),
+            std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({4}), std::vector<int64_t>{0, 2, 3, 4}),
+            std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape({3}), std::vector<int64_t>{0, 2, 2}),
+            std::make_shared<ov::op::v0::Constant>(element::i64, ov::Shape(), std::vector<int64_t>{0}),
+            std::make_shared<ov::op::v0::Constant>(element::i8, ov::Shape({4}), std::vector<int8_t>{2, 2, 2, 2})),
         EmbeddingBagOffsetsSumParams(
             ov::PartialShape{5, 2},
             ov::element::u8,
@@ -189,7 +189,7 @@ INSTANTIATE_TEST_SUITE_P(
             ov::PartialShape{3, 2},
             ov::element::u8,
             std::vector<uint8_t>{6, 8, 1, 2, 16, 18},
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape({3}), std::vector<int32_t>{0, 2, 2}),
-            std::make_shared<ngraph::opset1::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0}))),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({4}), std::vector<int32_t>{0, 2, 3, 4}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape({3}), std::vector<int32_t>{0, 2, 2}),
+            std::make_shared<ov::op::v0::Constant>(element::i32, ov::Shape(), std::vector<int32_t>{0}))),
     ReferenceEmbeddingBagOffsetsSumLayerTest::getTestCaseName);
diff --git a/src/plugins/template/tests/functional/op_reference/embeddingbag_packedsum.cpp b/src/plugins/template/tests/functional/op_reference/embeddingbag_packedsum.cpp
index 3552178df7b..f81acb2d4e2 100644
--- a/src/plugins/template/tests/functional/op_reference/embeddingbag_packedsum.cpp
+++ b/src/plugins/template/tests/functional/op_reference/embeddingbag_packedsum.cpp
@@ -20,8 +20,8 @@ struct EmbeddingBagPackedSumParams {
                                 const ov::PartialShape& oShape,
                                 const ov::element::Type& oType,
                                 const std::vector<IT>& oValues,
-                                const std::shared_ptr<ngraph::opset1::Constant>& indices,
-                                const std::shared_ptr<ngraph::opset1::Constant>& per_sample_weights = nullptr)
+                                const std::shared_ptr<ov::op::v0::Constant>& indices,
+                                const std::shared_ptr<ov::op::v0::Constant>& per_sample_weights = nullptr)
         : _iShape(iShape),
           _iType(iType),
           _iData(CreateTensor(iType, iValues)),
@@ -39,8 +39,8 @@ struct EmbeddingBagPackedSumParams {
     ov::element::Type _refType;
     ov::Tensor _refData;
 
-    std::shared_ptr<ngraph::opset1::Constant> _indices;
-    std::shared_ptr<ngraph::opset1::Constant> _perSampleWeights;  // Optional, default is tensor of ones.
+    std::shared_ptr<ov::op::v0::Constant> _indices;
+    std::shared_ptr<ov::op::v0::Constant> _perSampleWeights;  // Optional, default is tensor of ones.
 };
 
 class ReferenceEmbeddingBagPackedSumLayerTest : public testing::TestWithParam<EmbeddingBagPackedSumParams>,
@@ -66,8 +66,8 @@ private:
     static std::shared_ptr<Model> CreateFunction(
         const PartialShape& input_shape,
         const element::Type& input_type,
-        const std::shared_ptr<ngraph::opset1::Constant> indices,
-        const std::shared_ptr<ngraph::opset1::Constant> per_sample_weights) {
+        const std::shared_ptr<ov::op::v0::Constant> indices,
+        const std::shared_ptr<ov::op::v0::Constant> per_sample_weights) {
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
 
         if (per_sample_weights) {
@@ -85,7 +85,7 @@ TEST_P(ReferenceEmbeddingBagPackedSumLayerTest, CompareWithRefs) {
 }
 
 template <class T>
-inline std::shared_ptr<ngraph::opset1::Constant> CreateConstant(const std::vector<std::vector<T>>& val,
+inline std::shared_ptr<ov::op::v0::Constant> CreateConstant(const std::vector<std::vector<T>>& val,
                                                                   const ov::element::Type& element_type) {
     if (val.size() > 0) {
         ov::Shape i_shape({val.size(), val[0].size()});
@@ -99,9 +99,9 @@ inline std::shared_ptr<ngraph::opset1::Constant> CreateConstant(const std::vecto
             }
         }
 
-        return std::make_shared<ngraph::opset1::Constant>(element_type, i_shape, i_values);
+        return std::make_shared<ov::op::v0::Constant>(element_type, i_shape, i_values);
     } else {
-        return std::make_shared<ngraph::opset1::Constant>(element_type, ov::Shape(), std::vector<T>());
+        return std::make_shared<ov::op::v0::Constant>(element_type, ov::Shape(), std::vector<T>());
     }
 }
 
diff --git a/src/plugins/template/tests/functional/op_reference/equal.cpp b/src/plugins/template/tests/functional/op_reference/equal.cpp
index 51310dfb998..6bed3aa52e5 100644
--- a/src/plugins/template/tests/functional/op_reference/equal.cpp
+++ b/src/plugins/template/tests/functional/op_reference/equal.cpp
@@ -8,7 +8,6 @@
 #include "comparison.hpp"
 
 using namespace ov;
-using ComparisonTypes = ngraph::helpers::ComparisonTypes;
 
 namespace reference_tests {
 namespace ComparisonOpsRefTestDefinitions {
diff --git a/src/plugins/template/tests/functional/op_reference/experimental_detectron_roi_feature_extractor.cpp b/src/plugins/template/tests/functional/op_reference/experimental_detectron_roi_feature_extractor.cpp
index f2a9cfc296d..10f5f7e4e10 100644
--- a/src/plugins/template/tests/functional/op_reference/experimental_detectron_roi_feature_extractor.cpp
+++ b/src/plugins/template/tests/functional/op_reference/experimental_detectron_roi_feature_extractor.cpp
@@ -127,13 +127,13 @@ INSTANTIATE_TEST_SUITE_P(
         ExperimentalROIParams(
             std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{2, 4},
                                        ov::element::f16,
-                                       std::vector<ngraph::float16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0}),
+                                       std::vector<ov::float16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0}),
                                 reference_tests::Tensor(Shape{1, 2, 2, 3},
                                        ov::element::f16,
-                                       std::vector<ngraph::float16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0})},
+                                       std::vector<ov::float16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0})},
             std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{2, 2, 3, 3},
                                        ov::element::f16,
-                                       std::vector<ngraph::float16>{1.416667,
+                                       std::vector<ov::float16>{1.416667,
                                                                     1.75,
                                                                     2.083333,
                                                                     2.416667,
@@ -171,18 +171,18 @@ INSTANTIATE_TEST_SUITE_P(
                                                                     5.416667}),
                                 reference_tests::Tensor(Shape{2, 4},
                                        ov::element::f16,
-                                       std::vector<ngraph::float16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0})},
+                                       std::vector<ov::float16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0})},
             "experimental_detectron_roi_feature_eval_f16"),
         ExperimentalROIParams(
             std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{2, 4},
                                        ov::element::bf16,
-                                       std::vector<ngraph::bfloat16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0}),
+                                       std::vector<ov::bfloat16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0}),
                                 reference_tests::Tensor(Shape{1, 2, 2, 3},
                                        ov::element::bf16,
-                                       std::vector<ngraph::bfloat16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0})},
+                                       std::vector<ov::bfloat16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0})},
             std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{2, 2, 3, 3},
                                        ov::element::bf16,
-                                       std::vector<ngraph::bfloat16>{1.416667,
+                                       std::vector<ov::bfloat16>{1.416667,
                                                                      1.75,
                                                                      2.083333,
                                                                      2.416667,
@@ -220,5 +220,5 @@ INSTANTIATE_TEST_SUITE_P(
                                                                      5.416667}),
                                 reference_tests::Tensor(Shape{2, 4},
                                        ov::element::bf16,
-                                       std::vector<ngraph::bfloat16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0})},
+                                       std::vector<ov::bfloat16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0})},
             "experimental_detectron_roi_feature_eval_bf16")));
diff --git a/src/plugins/template/tests/functional/op_reference/greater.cpp b/src/plugins/template/tests/functional/op_reference/greater.cpp
index b266307175a..7070005244a 100644
--- a/src/plugins/template/tests/functional/op_reference/greater.cpp
+++ b/src/plugins/template/tests/functional/op_reference/greater.cpp
@@ -8,7 +8,6 @@
 #include "comparison.hpp"
 
 using namespace ov;
-using ComparisonTypes = ngraph::helpers::ComparisonTypes;
 
 namespace reference_tests {
 namespace ComparisonOpsRefTestDefinitions {
diff --git a/src/plugins/template/tests/functional/op_reference/greater_equal.cpp b/src/plugins/template/tests/functional/op_reference/greater_equal.cpp
index 04ffb561d7c..c8f18a3b21c 100644
--- a/src/plugins/template/tests/functional/op_reference/greater_equal.cpp
+++ b/src/plugins/template/tests/functional/op_reference/greater_equal.cpp
@@ -8,7 +8,6 @@
 #include "comparison.hpp"
 
 using namespace ov;
-using ComparisonTypes = ngraph::helpers::ComparisonTypes;
 
 namespace reference_tests {
 namespace ComparisonOpsRefTestDefinitions {
diff --git a/src/plugins/template/tests/functional/op_reference/hard_sigmoid.cpp b/src/plugins/template/tests/functional/op_reference/hard_sigmoid.cpp
index f8ba47d329e..d6142cf83d7 100644
--- a/src/plugins/template/tests/functional/op_reference/hard_sigmoid.cpp
+++ b/src/plugins/template/tests/functional/op_reference/hard_sigmoid.cpp
@@ -3,10 +3,10 @@
 //
 
 #include <gtest/gtest.h>
-#include <ngraph/ngraph.hpp>
 
 #include "openvino/op/hard_sigmoid.hpp"
 #include "base_reference_test.hpp"
+#include "openvino/op/constant.hpp"
 
 using namespace reference_tests;
 using namespace ov;
@@ -60,8 +60,8 @@ private:
         alphaArray.push_back(alphaData);
         betaArray.push_back(betaData);
         const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
-        const auto alpha = ngraph::op::Constant::create(input_type, Shape{}, {alphaData});
-        const auto beta = ngraph::op::Constant::create(input_type, Shape{}, {betaData});
+        const auto alpha = ov::op::v0::Constant::create(input_type, Shape{}, {alphaData});
+        const auto beta = ov::op::v0::Constant::create(input_type, Shape{}, {betaData});
         const auto HardSigmoid = std::make_shared<op::v0::HardSigmoid>(in, alpha, beta);
         return std::make_shared<ov::Model>(NodeVector {HardSigmoid}, ParameterVector {in});
     }
diff --git a/src/plugins/template/tests/functional/op_reference/if.cpp b/src/plugins/template/tests/functional/op_reference/if.cpp
index fbc0ad83f2b..64a3b0d99a0 100644
--- a/src/plugins/template/tests/functional/op_reference/if.cpp
+++ b/src/plugins/template/tests/functional/op_reference/if.cpp
@@ -6,9 +6,7 @@
 
 #include <algorithm>
 #include <ie_core.hpp>
-#include <ie_ngraph_utils.hpp>
 #include <limits>
-#include <ngraph/ngraph.hpp>
 #include <shared_test_classes/base/layer_test_utils.hpp>
 
 #include "base_reference_test.hpp"
@@ -26,12 +24,12 @@ struct IfFunctionalBase {
 struct IfCondConst : public IfFunctionalBase {
     std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs,
                                               const std::vector<reference_tests::Tensor>& results) override {
-        NGRAPH_CHECK(if_inputs.size() == 2, "Incorrect test case! Number of inputs is not 2.");
-        NGRAPH_CHECK(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
+        OPENVINO_ASSERT(if_inputs.size() == 2, "Incorrect test case! Number of inputs is not 2.");
+        OPENVINO_ASSERT(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
 
         auto X = std::make_shared<op::v0::Parameter>(if_inputs[0].type, if_inputs[0].shape);
         auto Y = std::make_shared<op::v0::Parameter>(if_inputs[1].type, if_inputs[1].shape);
-        auto cond = std::make_shared<op::v0::Constant>(ngraph::element::boolean, Shape{1}, cond_value);
+        auto cond = std::make_shared<op::v0::Constant>(ov::element::boolean, Shape{1}, cond_value);
         auto Xt = std::make_shared<op::v0::Parameter>(if_inputs[0].type, PartialShape::dynamic());
         auto Yt = std::make_shared<op::v0::Parameter>(if_inputs[1].type, PartialShape::dynamic());
         auto Xe = std::make_shared<op::v0::Parameter>(if_inputs[0].type, PartialShape::dynamic());
@@ -58,8 +56,8 @@ struct IfCondConst : public IfFunctionalBase {
 struct IfCondIsNonConst : public IfFunctionalBase {
     std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs,
                                               const std::vector<reference_tests::Tensor>& results) override {
-        NGRAPH_CHECK(if_inputs.size() == 3, "Incorrect test case! Number of inputs is not 3.");
-        NGRAPH_CHECK(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
+        OPENVINO_ASSERT(if_inputs.size() == 3, "Incorrect test case! Number of inputs is not 3.");
+        OPENVINO_ASSERT(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
 
         auto X = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
         auto Y = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
@@ -92,8 +90,8 @@ struct IfCondIsNonConst : public IfFunctionalBase {
 struct IfWithoutAdditionalInputs : IfFunctionalBase {
     std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs,
                                               const std::vector<reference_tests::Tensor>& results) override {
-        NGRAPH_CHECK(if_inputs.size() == 1, "Incorrect test case! Number of inputs is not 1.");
-        NGRAPH_CHECK(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
+        OPENVINO_ASSERT(if_inputs.size() == 1, "Incorrect test case! Number of inputs is not 1.");
+        OPENVINO_ASSERT(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
 
         auto cond = std::make_shared<op::v0::Parameter>(element::boolean, Shape{1});
         auto A = std::make_shared<op::v0::Constant>(element::f32, Shape{1}, 8.0);
@@ -114,8 +112,8 @@ struct IfWithoutAdditionalInputs : IfFunctionalBase {
 struct IfDynamismCaseWithStaticInputs : public IfFunctionalBase {
     std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs,
                                               const std::vector<reference_tests::Tensor>& results) override {
-        NGRAPH_CHECK(if_inputs.size() == 4, "Incorrect test case! Number of inputs is not 4.");
-        NGRAPH_CHECK(results.size() == 2, "Incorrect test case! Number of outputs is not 2.");
+        OPENVINO_ASSERT(if_inputs.size() == 4, "Incorrect test case! Number of inputs is not 4.");
+        OPENVINO_ASSERT(results.size() == 2, "Incorrect test case! Number of outputs is not 2.");
 
         auto X = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
         auto Y = std::make_shared<op::v0::Parameter>(element::f32, Shape{4, 2, 2});
@@ -156,8 +154,8 @@ struct IfDynamismCaseWithStaticInputs : public IfFunctionalBase {
 struct IfConditionIsScalar : public IfFunctionalBase {
     std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs,
                                               const std::vector<reference_tests::Tensor>& results) override {
-        NGRAPH_CHECK(if_inputs.size() == 3, "Incorrect test case! Number of inputs is not 3.");
-        NGRAPH_CHECK(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
+        OPENVINO_ASSERT(if_inputs.size() == 3, "Incorrect test case! Number of inputs is not 3.");
+        OPENVINO_ASSERT(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
 
         auto X = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
         auto Y = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
@@ -192,8 +190,8 @@ struct IfConditionIsScalar : public IfFunctionalBase {
 struct IfConditionIsDynamic : public IfFunctionalBase {
     std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs,
                                               const std::vector<reference_tests::Tensor>& results) override {
-        NGRAPH_CHECK(if_inputs.size() == 3, "Incorrect test case! Number of inputs is not 3.");
-        NGRAPH_CHECK(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
+        OPENVINO_ASSERT(if_inputs.size() == 3, "Incorrect test case! Number of inputs is not 3.");
+        OPENVINO_ASSERT(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
 
         auto X = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
         auto Y = std::make_shared<op::v0::Parameter>(element::f32, Shape{1, 2, 2});
@@ -227,8 +225,8 @@ struct IfConditionIsDynamic : public IfFunctionalBase {
 struct IfDynamicInputs : public IfFunctionalBase {
     std::shared_ptr<Model> create_function(const std::vector<reference_tests::Tensor>& if_inputs,
                                            const std::vector<reference_tests::Tensor>& results) override {
-        NGRAPH_CHECK(if_inputs.size() == 3, "Incorrect test case! Number of inputs is not 3.");
-        NGRAPH_CHECK(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
+        OPENVINO_ASSERT(if_inputs.size() == 3, "Incorrect test case! Number of inputs is not 3.");
+        OPENVINO_ASSERT(results.size() == 1, "Incorrect test case! Number of outputs is not 1.");
 
         auto X = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic());
         auto Y = std::make_shared<op::v0::Parameter>(element::f32, PartialShape::dynamic());
@@ -322,95 +320,95 @@ INSTANTIATE_TEST_SUITE_P(
     ::testing::Values(
         IfParams(
             std::make_shared<IfCondConst>(true),
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 1.0, 1.0, 1.0}),
-                                reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 2.0, 2.0, 2.0})},
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 2.0, 2.0, 2.0})},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 1.0, 1.0, 1.0}),
+                                reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 2.0, 2.0, 2.0})},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 2.0, 2.0, 2.0})},
             "if_condition_const_is_true"),
         IfParams(
             std::make_shared<IfCondConst>(false),
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 1.0, 1.0, 1.0}),
-                                reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 2.0, 2.0, 2.0})},
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 1.0, 1.0, 1.0})},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 1.0, 1.0, 1.0}),
+                                reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 2.0, 2.0, 2.0})},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 1.0, 1.0, 1.0})},
             "if_condition_const_is_false"),
         IfParams(
             std::make_shared<IfCondIsNonConst>(),
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ngraph::element::boolean, std::vector<unsigned char>{1}),
-                                reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
-                                reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 2.0, 6.0, 12.0})},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ov::element::boolean, std::vector<unsigned char>{1}),
+                                reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
+                                reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 2.0, 6.0, 12.0})},
             "if_condition_si_non_const_true"),
         IfParams(
             std::make_shared<IfCondIsNonConst>(),
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ngraph::element::boolean, std::vector<unsigned char>{0}),
-                                reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
-                                reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{3.0, 3.0, 5.0, 7.0})},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ov::element::boolean, std::vector<unsigned char>{0}),
+                                reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
+                                reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{3.0, 3.0, 5.0, 7.0})},
             "if_condition_is_non_const_false"),
         IfParams(std::make_shared<IfWithoutAdditionalInputs>(),
-                 std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ngraph::element::boolean, std::vector<unsigned char>{1})},
-                 std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ngraph::element::f32, std::vector<float>{8.0})},
+                 std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ov::element::boolean, std::vector<unsigned char>{1})},
+                 std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ov::element::f32, std::vector<float>{8.0})},
                  "if_without_addition_inputs_condition_is_true"),
         IfParams(std::make_shared<IfWithoutAdditionalInputs>(),
-                 std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ngraph::element::boolean, std::vector<unsigned char>{0})},
-                 std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ngraph::element::f32, std::vector<float>{2.0})},
+                 std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ov::element::boolean, std::vector<unsigned char>{0})},
+                 std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1}, ov::element::f32, std::vector<float>{2.0})},
                  "if_without_addition_inputs_condition_is_false"),
         IfParams(
             std::make_shared<IfConditionIsScalar>(),
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ngraph::element::boolean, std::vector<unsigned char>{1}),
-                                reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
-                                reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 2.0, 6.0, 12.0})},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ov::element::boolean, std::vector<unsigned char>{1}),
+                                reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
+                                reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 2.0, 6.0, 12.0})},
             "if_condition_is_scalar_cond_true"),
         IfParams(
             std::make_shared<IfConditionIsScalar>(),
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ngraph::element::boolean, std::vector<unsigned char>{0}),
-                                reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
-                                reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{3.0, 3.0, 5.0, 7.0})},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ov::element::boolean, std::vector<unsigned char>{0}),
+                                reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
+                                reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{3.0, 3.0, 5.0, 7.0})},
             "if_condition_is_scalar_cond_false"),
         IfParams(
             std::make_shared<IfDynamismCaseWithStaticInputs>(),
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ngraph::element::boolean, std::vector<unsigned char>{1}),
-                                reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
-                                reference_tests::Tensor(Shape{4, 2, 2}, ngraph::element::f32, Y_gen()),
-                                reference_tests::Tensor(Shape{8, 8, 8}, ngraph::element::f32, Z_gen())},
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 4.0, 9.0, 16.0}),
-                                reference_tests::Tensor(Shape{4, 2, 2}, ngraph::element::f32, Y_gen())},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ov::element::boolean, std::vector<unsigned char>{1}),
+                                reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
+                                reference_tests::Tensor(Shape{4, 2, 2}, ov::element::f32, Y_gen()),
+                                reference_tests::Tensor(Shape{8, 8, 8}, ov::element::f32, Z_gen())},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 4.0, 9.0, 16.0}),
+                                reference_tests::Tensor(Shape{4, 2, 2}, ov::element::f32, Y_gen())},
             "If_dynamism_case_with_static_inputs_condition_true"),
         IfParams(
             std::make_shared<IfDynamismCaseWithStaticInputs>(),
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ngraph::element::boolean, std::vector<unsigned char>{0}),
-                                reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
-                                reference_tests::Tensor(Shape{4, 2, 2}, ngraph::element::f32, Y_gen()),
-                                reference_tests::Tensor(Shape{8, 8, 8}, ngraph::element::f32, Z_gen())},
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 4.0, 6.0, 8.0}),
-                                reference_tests::Tensor(Shape{8, 8, 8}, ngraph::element::f32, Z_gen())},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ov::element::boolean, std::vector<unsigned char>{0}),
+                                reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
+                                reference_tests::Tensor(Shape{4, 2, 2}, ov::element::f32, Y_gen()),
+                                reference_tests::Tensor(Shape{8, 8, 8}, ov::element::f32, Z_gen())},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 4.0, 6.0, 8.0}),
+                                reference_tests::Tensor(Shape{8, 8, 8}, ov::element::f32, Z_gen())},
             "If_dynamism_case_with_static_inputs_condition_false"),
         IfParams(
             std::make_shared<IfConditionIsDynamic>(),
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ngraph::element::boolean, std::vector<unsigned char>{1}),
-                                reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
-                                reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 2.0, 6.0, 12.0})},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ov::element::boolean, std::vector<unsigned char>{1}),
+                                reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
+                                reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 2.0, 6.0, 12.0})},
             "if_condition_is_dynamic_cond_true"),
         IfParams(
             std::make_shared<IfConditionIsDynamic>(),
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ngraph::element::boolean, std::vector<unsigned char>{0}),
-                                reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
-                                reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{3.0, 3.0, 5.0, 7.0})},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ov::element::boolean, std::vector<unsigned char>{0}),
+                                reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
+                                reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{3.0, 3.0, 5.0, 7.0})},
             "if_condition_is_dynamic_cond_false"),
         IfParams(
             std::make_shared<IfDynamicInputs>(),
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ngraph::element::boolean, std::vector<unsigned char>{1}),
-                                reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
-                                reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 2.0, 6.0, 12.0})},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ov::element::boolean, std::vector<unsigned char>{1}),
+                                reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
+                                reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 2.0, 6.0, 12.0})},
             "if_dynamic_inputs_cond_true"),
         IfParams(
             std::make_shared<IfDynamicInputs>(),
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ngraph::element::boolean, std::vector<unsigned char>{0}),
-                                reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
-                                reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
-            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ngraph::element::f32, std::vector<float>{3.0, 3.0, 5.0, 7.0})},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{}, ov::element::boolean, std::vector<unsigned char>{0}),
+                                reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{1.0, 2.0, 3.0, 4.0}),
+                                reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{2.0, 1.0, 2.0, 3.0})},
+            std::vector<reference_tests::Tensor>{reference_tests::Tensor(Shape{1, 2, 2}, ov::element::f32, std::vector<float>{3.0, 3.0, 5.0, 7.0})},
             "if_dynamic_inputs_cond_false")));
diff --git a/src/plugins/template/tests/functional/op_reference/less.cpp b/src/plugins/template/tests/functional/op_reference/less.cpp
index 2001659482c..0c540020de8 100644
--- a/src/plugins/template/tests/functional/op_reference/less.cpp
+++ b/src/plugins/template/tests/functional/op_reference/less.cpp
@@ -8,7 +8,6 @@
 #include "comparison.hpp"
 
 using namespace ov;
-using ComparisonTypes = ngraph::helpers::ComparisonTypes;
 
 namespace reference_tests {
 namespace ComparisonOpsRefTestDefinitions {
diff --git a/src/plugins/template/tests/functional/op_reference/less_eq.cpp b/src/plugins/template/tests/functional/op_reference/less_eq.cpp
index 50ee8cc5916..4e6122dd8bb 100644
--- a/src/plugins/template/tests/functional/op_reference/less_eq.cpp
+++ b/src/plugins/template/tests/functional/op_reference/less_eq.cpp
@@ -8,7 +8,6 @@
 #include "comparison.hpp"
 
 using namespace ov;
-using ComparisonTypes = ngraph::helpers::ComparisonTypes;
 
 namespace reference_tests {
 namespace ComparisonOpsRefTestDefinitions {
diff --git a/src/plugins/template/tests/functional/op_reference/logical.hpp b/src/plugins/template/tests/functional/op_reference/logical.hpp
index ad8b969e662..f5bd6c0e9a3 100644
--- a/src/plugins/template/tests/functional/op_reference/logical.hpp
+++ b/src/plugins/template/tests/functional/op_reference/logical.hpp
@@ -5,15 +5,26 @@
 #include <gtest/gtest.h>
 
 #include "base_reference_test.hpp"
-#include "ngraph_functions/builders.hpp"
+
+#include "openvino/op/logical_and.hpp"
+#include "openvino/op/logical_not.hpp"
+#include "openvino/op/logical_or.hpp"
+#include "openvino/op/logical_xor.hpp"
 
 using namespace ov;
 
 namespace reference_tests {
 namespace LogicalOpsRefTestDefinitions {
 
+enum LogicalTypes {
+    LOGICAL_AND,
+    LOGICAL_OR,
+    LOGICAL_XOR,
+    LOGICAL_NOT
+};
+
 struct RefLogicalParams {
-    ngraph::helpers::LogicalTypes opType;
+    LogicalTypes opType;
     std::vector<reference_tests::Tensor> inputs;
     reference_tests::Tensor expected;
 };
@@ -48,13 +59,34 @@ public:
     }
 
 private:
-    static std::shared_ptr<ov::Model> CreateFunction(ngraph::helpers::LogicalTypes op_type, const std::vector<reference_tests::Tensor>& inputs) {
+    static std::shared_ptr<ov::Model> CreateFunction(LogicalTypes op_type, const std::vector<reference_tests::Tensor>& inputs) {
         ov::ParameterVector params_vec;
         for (auto& input : inputs) {
             params_vec.push_back(std::make_shared<op::v0::Parameter>(input.type, input.shape));
         }
 
-        const auto logical_op = ngraph::builder::makeLogical(params_vec, op_type);
+        std::shared_ptr<ov::Node> logical_op;
+        switch (op_type) {
+        case LogicalTypes::LOGICAL_AND: {
+            logical_op = std::make_shared<ov::op::v1::LogicalAnd>(params_vec[0], params_vec[1]);
+            break;
+        }
+        case LogicalTypes::LOGICAL_OR: {
+            logical_op = std::make_shared<ov::op::v1::LogicalOr>(params_vec[0], params_vec[1]);
+            break;
+        }
+        case LogicalTypes::LOGICAL_NOT: {
+            logical_op = std::make_shared<ov::op::v1::LogicalNot>(params_vec[0]);
+            break;
+        }
+        case LogicalTypes::LOGICAL_XOR: {
+            logical_op = std::make_shared<ov::op::v1::LogicalXor>(params_vec[0], params_vec[1]);
+            break;
+        }
+        default: {
+            throw std::runtime_error("Incorrect type of Logical operation");
+        }
+    }
         return std::make_shared<ov::Model>(ov::NodeVector {logical_op}, ov::ParameterVector {params_vec});
     }
 };
diff --git a/src/plugins/template/tests/functional/op_reference/logical_and.cpp b/src/plugins/template/tests/functional/op_reference/logical_and.cpp
index 178beb832bd..254b3e0c8d8 100644
--- a/src/plugins/template/tests/functional/op_reference/logical_and.cpp
+++ b/src/plugins/template/tests/functional/op_reference/logical_and.cpp
@@ -8,7 +8,6 @@
 #include "logical.hpp"
 
 using namespace ov;
-using LogicalTypes = ngraph::helpers::LogicalTypes;
 
 namespace reference_tests {
 namespace LogicalOpsRefTestDefinitions {
diff --git a/src/plugins/template/tests/functional/op_reference/logical_not.cpp b/src/plugins/template/tests/functional/op_reference/logical_not.cpp
index 9ec16abe8e6..fb63207d99a 100644
--- a/src/plugins/template/tests/functional/op_reference/logical_not.cpp
+++ b/src/plugins/template/tests/functional/op_reference/logical_not.cpp
@@ -8,7 +8,6 @@
 #include "logical.hpp"
 
 using namespace ov;
-using LogicalTypes = ngraph::helpers::LogicalTypes;
 
 namespace reference_tests {
 namespace LogicalOpsRefTestDefinitions {
diff --git a/src/plugins/template/tests/functional/op_reference/logical_or.cpp b/src/plugins/template/tests/functional/op_reference/logical_or.cpp
index 247d14bf5d9..34249cfea69 100644
--- a/src/plugins/template/tests/functional/op_reference/logical_or.cpp
+++ b/src/plugins/template/tests/functional/op_reference/logical_or.cpp
@@ -8,7 +8,6 @@
 #include "logical.hpp"
 
 using namespace ov;
-using LogicalTypes = ngraph::helpers::LogicalTypes;
 
 namespace reference_tests {
 namespace LogicalOpsRefTestDefinitions {
diff --git a/src/plugins/template/tests/functional/op_reference/logical_xor.cpp b/src/plugins/template/tests/functional/op_reference/logical_xor.cpp
index 2c292253757..30be39f2e77 100644
--- a/src/plugins/template/tests/functional/op_reference/logical_xor.cpp
+++ b/src/plugins/template/tests/functional/op_reference/logical_xor.cpp
@@ -8,7 +8,6 @@
 #include "logical.hpp"
 
 using namespace ov;
-using LogicalTypes = ngraph::helpers::LogicalTypes;
 
 namespace reference_tests {
 namespace LogicalOpsRefTestDefinitions {
diff --git a/src/plugins/template/tests/functional/op_reference/loop.cpp b/src/plugins/template/tests/functional/op_reference/loop.cpp
index 61e0c92f651..3a760b0b809 100644
--- a/src/plugins/template/tests/functional/op_reference/loop.cpp
+++ b/src/plugins/template/tests/functional/op_reference/loop.cpp
@@ -44,8 +44,8 @@ struct LoopDynamicInputs : public LoopFunctionalBase {
         auto M_body = std::make_shared<ov::opset8::Parameter>(ov::element::f32, ov::PartialShape::dynamic());
         auto body_condition = std::make_shared<ov::opset8::Constant>(ov::element::boolean, ov::Shape{1}, true);
 
-        auto trip_count = std::make_shared<ov::opset8::Constant>(ngraph::element::i64, ov::Shape{1}, 3);
-        auto exec_condition = std::make_shared<ov::opset8::Constant>(ngraph::element::boolean, ov::Shape{1}, true);
+        auto trip_count = std::make_shared<ov::opset8::Constant>(ov::element::i64, ov::Shape{1}, 3);
+        auto exec_condition = std::make_shared<ov::opset8::Constant>(ov::element::boolean, ov::Shape{1}, true);
         // Body
         auto sum = std::make_shared<ov::opset8::Add>(Xi, Yi);
         auto Zo = std::make_shared<ov::opset8::Multiply>(sum, M_body);
diff --git a/src/plugins/template/tests/functional/op_reference/mvn.cpp b/src/plugins/template/tests/functional/op_reference/mvn.cpp
index a02cd5ff810..5816351c2da 100644
--- a/src/plugins/template/tests/functional/op_reference/mvn.cpp
+++ b/src/plugins/template/tests/functional/op_reference/mvn.cpp
@@ -14,7 +14,7 @@ using namespace reference_tests;
 // ------------------------------ V0 ------------------------------
 
 struct MVN1Params {
-    MVN1Params(const reference_tests::Tensor& paramInput, const ngraph::AxisSet& paramReductionAxes, const bool paramAcrossChannels, const bool paramNormalizeVariance,
+    MVN1Params(const reference_tests::Tensor& paramInput, const ov::AxisSet& paramReductionAxes, const bool paramAcrossChannels, const bool paramNormalizeVariance,
                const double paramEps, const reference_tests::Tensor& paramExpected)
         : input(paramInput),
           reductionAxes(paramReductionAxes),
@@ -23,7 +23,7 @@ struct MVN1Params {
           eps(paramEps),
           expected(paramExpected) {}
     reference_tests::Tensor input;
-    ngraph::AxisSet reductionAxes;
+    ov::AxisSet reductionAxes;
     bool acrossChannels;
     bool normalizeVariance;
     double eps;
@@ -54,7 +54,7 @@ public:
     }
 
 private:
-    static std::shared_ptr<Model> CreateFunction(const reference_tests::Tensor& input, const ngraph::AxisSet& reductionAxes, const bool acrossChannels,
+    static std::shared_ptr<Model> CreateFunction(const reference_tests::Tensor& input, const ov::AxisSet& reductionAxes, const bool acrossChannels,
                                                     const bool normalizeVariance, const double eps) {
         const auto in = std::make_shared<op::v0::Parameter>(input.type, input.shape);
         auto mvn = std::make_shared<op::v0::MVN>(in, acrossChannels, normalizeVariance, eps);
@@ -69,7 +69,7 @@ TEST_P(ReferenceMVN1LayerTest, CompareWithHardcodedRefs) {
     Exec();
 }
 
-const ngraph::AxisSet emptyReductionAxes {};
+const ov::AxisSet emptyReductionAxes {};
 
 INSTANTIATE_TEST_SUITE_P(
     smoke_MVN1_With_Hardcoded_Refs, ReferenceMVN1LayerTest,
diff --git a/src/plugins/template/tests/functional/op_reference/not_equal.cpp b/src/plugins/template/tests/functional/op_reference/not_equal.cpp
index dca6ec1405c..c02c5ea537f 100644
--- a/src/plugins/template/tests/functional/op_reference/not_equal.cpp
+++ b/src/plugins/template/tests/functional/op_reference/not_equal.cpp
@@ -8,8 +8,6 @@
 #include "comparison.hpp"
 
 using namespace ov;
-using ComparisonTypes = ngraph::helpers::ComparisonTypes;
-
 
 namespace reference_tests {
 namespace ComparisonOpsRefTestDefinitions {
diff --git a/src/plugins/template/tests/functional/op_reference/prelu.cpp b/src/plugins/template/tests/functional/op_reference/prelu.cpp
index e3efb48763d..bfc9c949dec 100644
--- a/src/plugins/template/tests/functional/op_reference/prelu.cpp
+++ b/src/plugins/template/tests/functional/op_reference/prelu.cpp
@@ -4,7 +4,6 @@
 
 #include <gtest/gtest.h>
 
-#include <ngraph_functions/builders.hpp>
 #include "openvino/op/prelu.hpp"
 #include "base_reference_test.hpp"
 
diff --git a/src/plugins/template/tests/functional/op_reference/reduce_l1.cpp b/src/plugins/template/tests/functional/op_reference/reduce_l1.cpp
index a0bf3d5ff30..63802601ad0 100644
--- a/src/plugins/template/tests/functional/op_reference/reduce_l1.cpp
+++ b/src/plugins/template/tests/functional/op_reference/reduce_l1.cpp
@@ -8,7 +8,6 @@
 #include "reduction.hpp"
 
 using namespace ov;
-using ReductionType = ngraph::helpers::ReductionType;
 
 namespace reference_tests {
 namespace ReductionOpsRefTestDefinitions {
@@ -20,7 +19,7 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
     std::vector<ReductionParams> params = {
         ReductionParams(ReductionType::L1, keep_dims, std::vector<int64_t>{2},
                         reference_tests::Tensor({3, 2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 2, 2}, AxisSet{2}, keep_dims),
+                        reference_tests::Tensor(reduce(Shape{3, 2, 2}, AxisSet{2}, keep_dims),
                                 element::Type(IN_ET), std::vector<T>{3, 7, 11, 15, 19, 23}))
     };
     return params;
diff --git a/src/plugins/template/tests/functional/op_reference/reduce_l2.cpp b/src/plugins/template/tests/functional/op_reference/reduce_l2.cpp
index 5256a79503b..a0e7439c661 100644
--- a/src/plugins/template/tests/functional/op_reference/reduce_l2.cpp
+++ b/src/plugins/template/tests/functional/op_reference/reduce_l2.cpp
@@ -8,7 +8,6 @@
 #include "reduction.hpp"
 
 using namespace ov;
-using ReductionType = ngraph::helpers::ReductionType;
 
 namespace reference_tests {
 namespace ReductionOpsRefTestDefinitions {
@@ -21,7 +20,7 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
     std::vector<ReductionParams> params = {
         ReductionParams(ReductionType::L2, keep_dims, std::vector<int64_t>{2},
                         reference_tests::Tensor({3, 2, 2}, element::Type(IN_ET), std::vector<T>{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 2, 2}, AxisSet{2}, keep_dims),
+                        reference_tests::Tensor(reduce(Shape{3, 2, 2}, AxisSet{2}, keep_dims),
                                 element::Type(IN_ET), std::vector<T>{2.23606798, 5.0, 7.81024968, 10.63014581, 13.45362405, 16.2788206}))
     };
     return params;
@@ -34,7 +33,7 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
     std::vector<ReductionParams> params = {
         ReductionParams(ReductionType::L2, keep_dims, std::vector<int64_t>{2},
                         reference_tests::Tensor({3, 2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 2, 2}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{2, 5, 8, 11, 13, 16}))
+                        reference_tests::Tensor(reduce(Shape{3, 2, 2}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{2, 5, 8, 11, 13, 16}))
     };
     return params;
 }
diff --git a/src/plugins/template/tests/functional/op_reference/reduce_max.cpp b/src/plugins/template/tests/functional/op_reference/reduce_max.cpp
index 185b6b7be63..97233a73e9e 100644
--- a/src/plugins/template/tests/functional/op_reference/reduce_max.cpp
+++ b/src/plugins/template/tests/functional/op_reference/reduce_max.cpp
@@ -8,7 +8,6 @@
 #include "reduction.hpp"
 
 using namespace ov;
-using ReductionType = ngraph::helpers::ReductionType;
 
 namespace reference_tests {
 namespace ReductionOpsRefTestDefinitions {
@@ -20,30 +19,30 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
     std::vector<ReductionParams> params = {
         ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{0, 1},
                         reference_tests::Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{4})),
+                        reference_tests::Tensor(reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{4})),
         ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{0},
                         reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{5, 6})),
+                        reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{5, 6})),
         ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{1},
                         reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{2, 4, 6})),
+                        reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{2, 4, 6})),
         ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{0},
                         reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                                                                16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0}, keep_dims),
+                        reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{0}, keep_dims),
                               element::Type(IN_ET), std::vector<T>{19, 20, 21, 22, 23, 24, 25, 26, 27})),
         ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{2},
                         reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                                                                16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{3, 6, 9, 12, 15, 18, 21, 24, 27})),
+                        reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{3, 6, 9, 12, 15, 18, 21, 24, 27})),
         ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{0, 1},
                         reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                                                                16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{25, 26, 27})),
+                        reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{25, 26, 27})),
         ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{0, 1, 2},
                         reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                                                                16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0, 1, 2}, keep_dims), element::Type(IN_ET), std::vector<T>{27}))
+                        reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{0, 1, 2}, keep_dims), element::Type(IN_ET), std::vector<T>{27}))
     };
     return params;
 }
diff --git a/src/plugins/template/tests/functional/op_reference/reduce_mean.cpp b/src/plugins/template/tests/functional/op_reference/reduce_mean.cpp
index c81dc625ae3..2baf98e48a8 100644
--- a/src/plugins/template/tests/functional/op_reference/reduce_mean.cpp
+++ b/src/plugins/template/tests/functional/op_reference/reduce_mean.cpp
@@ -8,7 +8,6 @@
 #include "reduction.hpp"
 
 using namespace ov;
-using ReductionType = ngraph::helpers::ReductionType;
 
 namespace reference_tests {
 namespace ReductionOpsRefTestDefinitions {
@@ -21,13 +20,13 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
     std::vector<ReductionParams> params = {
         ReductionParams(ReductionType::Mean, keep_dims, std::vector<int64_t>{0, 1},
                         reference_tests::Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{2.5})),
+                        reference_tests::Tensor(reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{2.5})),
         ReductionParams(ReductionType::Mean, keep_dims, std::vector<int64_t>{0},
                         reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{3, 4})),
+                        reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{3, 4})),
         ReductionParams(ReductionType::Mean, keep_dims, std::vector<int64_t>{1},
                         reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{1.5, 3.5, 5.5}))
+                        reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{1.5, 3.5, 5.5}))
     };
     return params;
 }
@@ -39,13 +38,13 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
     std::vector<ReductionParams> params = {
         ReductionParams(ReductionType::Mean, keep_dims, std::vector<int64_t>{0, 1},
                         reference_tests::Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{2})),
+                        reference_tests::Tensor(reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{2})),
         ReductionParams(ReductionType::Mean, keep_dims, std::vector<int64_t>{0},
                         reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{3, 4})),
+                        reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{3, 4})),
         ReductionParams(ReductionType::Mean, keep_dims, std::vector<int64_t>{1},
                         reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 3, 5}))
+                        reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 3, 5}))
     };
     return params;
 }
diff --git a/src/plugins/template/tests/functional/op_reference/reduce_min.cpp b/src/plugins/template/tests/functional/op_reference/reduce_min.cpp
index aa4c14a99e4..ea0f583055d 100644
--- a/src/plugins/template/tests/functional/op_reference/reduce_min.cpp
+++ b/src/plugins/template/tests/functional/op_reference/reduce_min.cpp
@@ -8,7 +8,6 @@
 #include "reduction.hpp"
 
 using namespace ov;
-using ReductionType = ngraph::helpers::ReductionType;
 
 namespace reference_tests {
 namespace ReductionOpsRefTestDefinitions {
@@ -20,29 +19,29 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
     std::vector<ReductionParams> params = {
         ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{0, 1},
                         reference_tests::Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{1})),
+                        reference_tests::Tensor(reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{1})),
         ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{0},
                         reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 2})),
+                        reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 2})),
         ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{1},
                         reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 3, 5})),
+                        reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 3, 5})),
         ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{0},
                         reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                                                                16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9})),
+                        reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9})),
         ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{2},
                         reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                                                                16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 4, 7, 10, 13, 16, 19, 22, 25})),
+                        reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 4, 7, 10, 13, 16, 19, 22, 25})),
         ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{0, 1},
                         reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                                                                16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 2, 3})),
+                        reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 2, 3})),
         ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{0, 1, 2},
                         reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                                                                16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0, 1, 2}, keep_dims), element::Type(IN_ET), std::vector<T>{1}))
+                        reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{0, 1, 2}, keep_dims), element::Type(IN_ET), std::vector<T>{1}))
     };
     return params;
 }
diff --git a/src/plugins/template/tests/functional/op_reference/reduce_prod.cpp b/src/plugins/template/tests/functional/op_reference/reduce_prod.cpp
index f9171485bd4..b3780145838 100644
--- a/src/plugins/template/tests/functional/op_reference/reduce_prod.cpp
+++ b/src/plugins/template/tests/functional/op_reference/reduce_prod.cpp
@@ -8,7 +8,6 @@
 #include "reduction.hpp"
 
 using namespace ov;
-using ReductionType = ngraph::helpers::ReductionType;
 
 namespace reference_tests {
 namespace ReductionOpsRefTestDefinitions {
@@ -19,17 +18,17 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
     std::vector<ReductionParams> params = {
         ReductionParams(ReductionType::Prod, keep_dims, std::vector<int64_t>{0, 1},
                         reference_tests::Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{24})),
+                        reference_tests::Tensor(reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{24})),
         ReductionParams(ReductionType::Prod, keep_dims, std::vector<int64_t>{0},
                         reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{15, 48})),
+                        reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{15, 48})),
         ReductionParams(ReductionType::Prod, keep_dims, std::vector<int64_t>{1},
                         reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{2, 12, 30})),
+                        reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{2, 12, 30})),
         ReductionParams(ReductionType::Prod, keep_dims, std::vector<int64_t>{0},
                         reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                                                                16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{1 * 10 * 19,
+                        reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{1 * 10 * 19,
                                                                                                                    2 * 11 * 20,
                                                                                                                    3 * 12 * 21,
                                                                                                                    4 * 13 * 22,
@@ -41,7 +40,7 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
         ReductionParams(ReductionType::Prod, keep_dims, std::vector<int64_t>{2},
                         reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                                                                16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{1 * 2 * 3,
+                        reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{1 * 2 * 3,
                                                                                                                    4 * 5 * 6,
                                                                                                                    7 * 8 * 9,
                                                                                                                    10 * 11 * 12,
diff --git a/src/plugins/template/tests/functional/op_reference/reduce_sum.cpp b/src/plugins/template/tests/functional/op_reference/reduce_sum.cpp
index c1798806dad..850cd269a6c 100644
--- a/src/plugins/template/tests/functional/op_reference/reduce_sum.cpp
+++ b/src/plugins/template/tests/functional/op_reference/reduce_sum.cpp
@@ -8,7 +8,6 @@
 #include "reduction.hpp"
 
 using namespace ov;
-using ReductionType = ngraph::helpers::ReductionType;
 
 static std::mt19937_64 random_generator;
 
@@ -31,17 +30,17 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
     std::vector<ReductionParams> params = {
         ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0, 1},
                         reference_tests::Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{10})),
+                        reference_tests::Tensor(reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{10})),
         ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0},
                         reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{9, 12})),
+                        reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{9, 12})),
         ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{1},
                         reference_tests::Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{3, 7, 11})),
+                        reference_tests::Tensor(reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{3, 7, 11})),
         ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0},
                         reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                                                                16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{1 + 10 + 19,
+                        reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{1 + 10 + 19,
                                                                                                                    2 + 11 + 20,
                                                                                                                    3 + 12 + 21,
                                                                                                                    4 + 13 + 22,
@@ -53,7 +52,7 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
         ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{2},
                         reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                                                                16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{1 + 2 + 3,
+                        reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{1 + 2 + 3,
                                                                                                                    4 + 5 + 6,
                                                                                                                    7 + 8 + 9,
                                                                                                                    10 + 11 + 12,
@@ -65,19 +64,19 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
         ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0, 1},
                         reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                                                                16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0, 1}, keep_dims),
+                        reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{0, 1}, keep_dims),
                                element::Type(IN_ET), std::vector<T>{1 + 10 + 19 + 4 + 13 + 22 + 7 + 16 + 25,
                                                                                2 + 11 + 20 + 5 + 14 + 23 + 8 + 17 + 26,
                                                                                3 + 12 + 21 + 6 + 15 + 24 + 9 + 18 + 27})),
         ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0, 1, 2},
                         reference_tests::Tensor({3, 3, 3}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                                                                16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0, 1, 2}, keep_dims), element::Type(IN_ET),
+                        reference_tests::Tensor(reduce(Shape{3, 3, 3}, AxisSet{0, 1, 2}, keep_dims), element::Type(IN_ET),
                             std::vector<T>{1 + 10 + 19 + 4 + 13 + 22 + 7 + 16 + 25 + 2 + 11 + 20 + 5 + 14 + 23 + 8 +
                                            17 + 26 + 3 + 12 + 21 + 6 + 15 + 24 + 9 + 18 + 27})),
         ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0, 1, 2, 3, 4},
                         reference_tests::Tensor({3, 3, 3, 3, 3}, element::Type(IN_ET), std::vector<T>(static_cast<uint64_t>(std::pow(3, 5)), 1)),
-                        reference_tests::Tensor(ngraph::reduce(Shape{3, 3, 3, 3, 3}, AxisSet{0, 1, 2, 3, 4}, keep_dims), element::Type(IN_ET), std::vector<T>{243}))
+                        reference_tests::Tensor(reduce(Shape{3, 3, 3, 3, 3}, AxisSet{0, 1, 2, 3, 4}, keep_dims), element::Type(IN_ET), std::vector<T>{243}))
     };
     return params;
 }
@@ -88,12 +87,12 @@ std::vector<ReductionParams> generateReductionParamsFloat(const bool keep_dims)
     std::vector<ReductionParams> params = {
         ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0},
                         reference_tests::Tensor({1000000}, element::f32, in),
-                        reference_tests::Tensor(ngraph::reduce(Shape{1000000}, AxisSet{0}, keep_dims), element::f32, std::vector<float>{res})),
+                        reference_tests::Tensor(reduce(Shape{1000000}, AxisSet{0}, keep_dims), element::f32, std::vector<float>{res})),
         ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0},
                         reference_tests::Tensor({20}, element::f32, std::vector<float>{10000000.0f, 0.9f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f,
                                                                       0.8f,        0.1f, 0.9f, 0.5f, 0.2f, 0.3f, 0.4f,
                                                                       0.5f,        0.6f, 0.7f, 0.8f, 0.9f, 0.1f}),
-                        reference_tests::Tensor(ngraph::reduce(Shape{20}, AxisSet{0}, keep_dims), element::f32, std::vector<float>{10000010.2f}))
+                        reference_tests::Tensor(reduce(Shape{20}, AxisSet{0}, keep_dims), element::f32, std::vector<float>{10000010.2f}))
     };
     return params;
 }
diff --git a/src/plugins/template/tests/functional/op_reference/reduction.hpp b/src/plugins/template/tests/functional/op_reference/reduction.hpp
index 77ce7c597a7..30f6ca559fc 100644
--- a/src/plugins/template/tests/functional/op_reference/reduction.hpp
+++ b/src/plugins/template/tests/functional/op_reference/reduction.hpp
@@ -5,21 +5,48 @@
 #include <gtest/gtest.h>
 
 #include "base_reference_test.hpp"
+#include "common_test_utils/test_enums.hpp"
 #include "shared_test_classes/base/layer_test_utils.hpp"
-#include "ngraph_functions/builders.hpp"
-#include "ngraph/shape_util.hpp"
+#include "openvino/op/reduce_logical_and.hpp"
+#include "openvino/op/reduce_logical_or.hpp"
+#include "openvino/op/reduce_l1.hpp"
+#include "openvino/op/reduce_l2.hpp"
+#include "openvino/op/reduce_min.hpp"
+#include "openvino/op/reduce_max.hpp"
+#include "openvino/op/reduce_mean.hpp"
+#include "openvino/op/reduce_prod.hpp"
+#include "openvino/op/reduce_sum.hpp"
 
 using namespace ov;
 
 namespace reference_tests {
 namespace ReductionOpsRefTestDefinitions {
 
+using ov::test::utils::ReductionType;
+
+// Removes some values from a vector of axis values
+template <typename AXIS_VALUES>
+AXIS_VALUES reduce(const AXIS_VALUES& axis_values, const ov::AxisSet& deleted_axes, bool keep_dims) {
+    AXIS_VALUES result;
+
+    for (size_t i = 0; i < axis_values.size(); i++) {
+        if (deleted_axes.find(i) == deleted_axes.end()) {
+            result.push_back(axis_values[i]);
+        } else {
+            if (keep_dims)
+                result.push_back(1);
+        }
+    }
+
+    return result;
+}
+
 struct ReductionParams {
-    ReductionParams(const ngraph::helpers::ReductionType& reductType, const bool keepDims, const std::vector<int64_t>& axes,
+    ReductionParams(const ReductionType& reductType, const bool keepDims, const std::vector<int64_t>& axes,
         const reference_tests::Tensor& dataTensor, const reference_tests::Tensor& outputTensor) : reductionType(reductType), keepDimensions(keepDims), reductionAxes(axes),
         data(dataTensor), output(outputTensor) {}
 
-    ngraph::helpers::ReductionType reductionType;
+    ReductionType reductionType;
     bool keepDimensions;
     std::vector<int64_t> reductionAxes;
     reference_tests::Tensor data;
@@ -54,7 +81,47 @@ private:
         const auto axes = std::make_shared<op::v0::Constant>(ov::element::i64,
                                                              ov::Shape{params.reductionAxes.size()},
                                                              params.reductionAxes);
-        const auto reduction = ngraph::builder::makeReduce(data, axes, params.keepDimensions, params.reductionType);
+        std::shared_ptr<ov::Node> reduction;
+        switch (params.reductionType) {
+        case ReductionType::Mean: {
+            reduction = std::make_shared<ov::op::v1::ReduceMean>(data, axes, params.keepDimensions);
+            break;
+        }
+        case ReductionType::Max: {
+            reduction = std::make_shared<ov::op::v1::ReduceMax>(data, axes, params.keepDimensions);
+            break;
+        }
+        case ReductionType::Min: {
+            reduction = std::make_shared<ov::op::v1::ReduceMin>(data, axes, params.keepDimensions);
+            break;
+        }
+        case ReductionType::Prod: {
+            reduction = std::make_shared<ov::op::v1::ReduceProd>(data, axes, params.keepDimensions);
+            break;
+        }
+        case ReductionType::Sum: {
+            reduction = std::make_shared<ov::op::v1::ReduceSum>(data, axes, params.keepDimensions);
+            break;
+        }
+        case ReductionType::LogicalOr: {
+            reduction = std::make_shared<ov::op::v1::ReduceLogicalOr>(data, axes, params.keepDimensions);
+            break;
+        }
+        case ReductionType::LogicalAnd: {
+            reduction = std::make_shared<ov::op::v1::ReduceLogicalAnd>(data, axes, params.keepDimensions);
+            break;
+        }
+        case ReductionType::L1: {
+            reduction = std::make_shared<ov::op::v4::ReduceL1>(data, axes, params.keepDimensions);
+            break;
+        }
+        case ReductionType::L2: {
+            reduction = std::make_shared<ov::op::v4::ReduceL2>(data, axes, params.keepDimensions);
+            break;
+        }
+        default:
+            throw std::runtime_error("Can't create layer for this reduction type");
+        }
         return std::make_shared<ov::Model>(reduction, ov::ParameterVector{data});
     }
 };
diff --git a/src/plugins/template/tests/functional/op_reference/reverse.cpp b/src/plugins/template/tests/functional/op_reference/reverse.cpp
index 2025a14c9a4..48d3387cbd4 100644
--- a/src/plugins/template/tests/functional/op_reference/reverse.cpp
+++ b/src/plugins/template/tests/functional/op_reference/reverse.cpp
@@ -89,28 +89,28 @@ TEST_P(ReferenceReverseTestAxesRankIndexMode, CompareWithRefs) {
     EXPECT_THROW(const auto unused = std::make_shared<ov::Model>(
                      std::make_shared<op::v1::Reverse>(Data, Rev_Axes, op::v1::Reverse::Mode::INDEX),
                      ParameterVector{Data, Rev_Axes}),
-                 ngraph::NodeValidationFailure);
+                 ov::NodeValidationFailure);
 }
 
 TEST_P(ReferenceReverseTestAxesElemsMaskMode, CompareWithRefs) {
     const auto Data = std::make_shared<op::v0::Parameter>(element::f32, Shape{2, 2, 2});
     const auto Rev_Axes = std::make_shared<op::v0::Parameter>(element::boolean, Shape{2});  // correct: 3
     EXPECT_THROW(const auto unused = std::make_shared<op::v1::Reverse>(Data, Rev_Axes, op::v1::Reverse::Mode::MASK),
-                 ngraph::NodeValidationFailure);
+                 ov::NodeValidationFailure);
 }
 
 TEST_P(ReferenceReverseTestAxesOutOfBounds, CompareWithRefs) {
     const auto Data = std::make_shared<op::v0::Parameter>(element::f32, Shape{2, 2, 2});
     const auto Rev_Axes = op::v0::Constant::create(element::i64, Shape{2}, {1, 10});
     EXPECT_THROW(const auto unused = std::make_shared<op::v1::Reverse>(Data, Rev_Axes, op::v1::Reverse::Mode::INDEX),
-                 ngraph::NodeValidationFailure);
+                 ov::NodeValidationFailure);
 }
 
 TEST_P(ReferenceReverseTestAxesOutOfBounds4, CompareWithRefs) {
     const auto Data = std::make_shared<op::v0::Parameter>(element::f32, Shape{2, 2, 2});
     const auto Rev_Axes = op::v0::Constant::create(element::i64, Shape{4}, {0, 1, 2, 3});
     EXPECT_THROW(const auto unused = std::make_shared<op::v1::Reverse>(Data, Rev_Axes, op::v1::Reverse::Mode::INDEX),
-                 ngraph::NodeValidationFailure);
+                 ov::NodeValidationFailure);
 }
 
 template <element::Type_t IN_ET>
diff --git a/src/plugins/template/tests/functional/op_reference/scatter_update.cpp b/src/plugins/template/tests/functional/op_reference/scatter_update.cpp
index e2a932fec0d..47d17750c08 100644
--- a/src/plugins/template/tests/functional/op_reference/scatter_update.cpp
+++ b/src/plugins/template/tests/functional/op_reference/scatter_update.cpp
@@ -2,19 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <gtest/gtest.h>
 
-#include <ie_core.hpp>
-#include <ie_ngraph_utils.hpp>
-#include <ngraph/ngraph.hpp>
-#include <shared_test_classes/base/layer_test_utils.hpp>
 #include <vector>
 
 #include "base_reference_test.hpp"
-#include "ngraph_functions/builders.hpp"
+#include "gtest/gtest.h"
+#include "openvino/op/parameter.hpp"
+#include "openvino/op/scatter_update.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
 using namespace reference_tests;
 
 namespace reference_tests {
@@ -73,12 +68,12 @@ private:
         const auto indices_type = params.indices.type;
         const auto axis_type = params.axis.type;
 
-        const auto data = std::make_shared<ngraph::op::Parameter>(numeric_type, data_shape);
-        const auto indices = std::make_shared<ngraph::op::Parameter>(indices_type, indices_shape);
-        const auto updates = std::make_shared<ngraph::op::Parameter>(numeric_type, updates_shape);
-        const auto axis = std::make_shared<ngraph::op::Parameter>(axis_type, axis_shape);
-        const auto scatter_update = std::make_shared<op::v3::ScatterUpdate>(data, indices, updates, axis);
-        return std::make_shared<ov::Model>(ngraph::NodeVector {scatter_update}, ngraph::ParameterVector {data, indices, updates, axis});
+        const auto data = std::make_shared<ov::op::v0::Parameter>(numeric_type, data_shape);
+        const auto indices = std::make_shared<ov::op::v0::Parameter>(indices_type, indices_shape);
+        const auto updates = std::make_shared<ov::op::v0::Parameter>(numeric_type, updates_shape);
+        const auto axis = std::make_shared<ov::op::v0::Parameter>(axis_type, axis_shape);
+        const auto scatter_update = std::make_shared<ov::op::v3::ScatterUpdate>(data, indices, updates, axis);
+        return std::make_shared<ov::Model>(ov::NodeVector {scatter_update}, ov::ParameterVector {data, indices, updates, axis});
     }
 };
 
@@ -86,10 +81,10 @@ TEST_P(ReferenceScatterUpdate6LayerTest, ScatterUpdateWithHardcodedRefs) {
     Exec();
 }
 
-template <element::Type_t NUM_ET, element::Type_t INT_ET>
-std::vector<ScatterUpdate3Params> generateScatterUpdate3Params(const element::Type& numeric_type, const element::Type& integer_type) {
-    using N = typename element_type_traits<NUM_ET>::value_type;
-    using I = typename element_type_traits<INT_ET>::value_type;
+template <ov::element::Type_t NUM_ET, ov::element::Type_t INT_ET>
+std::vector<ScatterUpdate3Params> generateScatterUpdate3Params(const ov::element::Type& numeric_type, const ov::element::Type& integer_type) {
+    using N = typename ov::element_type_traits<NUM_ET>::value_type;
+    using I = typename ov::element_type_traits<INT_ET>::value_type;
     std::vector<ScatterUpdate3Params> ScatterUpdateParams {
         Builder {}
             .data({{3, 2, 2, 3}, numeric_type, std::vector<N> {
@@ -769,10 +764,10 @@ Builder {}
     return ScatterUpdateParams;
 }
 
-template <element::Type_t NUM_ET, element::Type_t INT_ET>
-std::vector<ScatterUpdate3Params> generateScatterUpdate3ParamsNegativeAxis(const element::Type& numeric_type, const element::Type& integer_type) {
-    using N = typename element_type_traits<NUM_ET>::value_type;
-    using I = typename element_type_traits<INT_ET>::value_type;
+template <ov::element::Type_t NUM_ET, ov::element::Type_t INT_ET>
+std::vector<ScatterUpdate3Params> generateScatterUpdate3ParamsNegativeAxis(const ov::element::Type& numeric_type, const ov::element::Type& integer_type) {
+    using N = typename ov::element_type_traits<NUM_ET>::value_type;
+    using I = typename ov::element_type_traits<INT_ET>::value_type;
     std::vector<ScatterUpdate3Params> ScatterUpdateParams {
         Builder {}
             .data({{2, 2, 3}, numeric_type, std::vector<N> {0, 0, 0,
@@ -870,72 +865,72 @@ std::vector<ScatterUpdate3Params> generateScatterUpdate3ParamsNegativeAxis(const
 std::vector<ScatterUpdate3Params> generateScatterUpdateCombinedParams() {
     const std::vector<std::vector<ScatterUpdate3Params>> ScatterUpdateTypeParams {
         // f32
-        generateScatterUpdate3Params<element::Type_t::f32, element::Type_t::i16>(element::f32, element::i16),
-        generateScatterUpdate3Params<element::Type_t::f32, element::Type_t::i32>(element::f32, element::i32),
-        generateScatterUpdate3Params<element::Type_t::f32, element::Type_t::i64>(element::f32, element::i64),
-        generateScatterUpdate3Params<element::Type_t::f32, element::Type_t::u32>(element::f32, element::u32),
-        generateScatterUpdate3Params<element::Type_t::f32, element::Type_t::u64>(element::f32, element::u64),
+        generateScatterUpdate3Params<ov::element::Type_t::f32, ov::element::Type_t::i16>(ov::element::f32, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::f32, ov::element::Type_t::i32>(ov::element::f32, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::f32, ov::element::Type_t::i64>(ov::element::f32, ov::element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::f32, ov::element::Type_t::u32>(ov::element::f32, ov::element::u32),
+        generateScatterUpdate3Params<ov::element::Type_t::f32, ov::element::Type_t::u64>(ov::element::f32, ov::element::u64),
 
         // f16
-        generateScatterUpdate3Params<element::Type_t::f16, element::Type_t::i16>(element::f16, element::i16),
-        generateScatterUpdate3Params<element::Type_t::f16, element::Type_t::i32>(element::f16, element::i32),
-        generateScatterUpdate3Params<element::Type_t::f16, element::Type_t::i64>(element::f16, element::i64),
-        generateScatterUpdate3Params<element::Type_t::f16, element::Type_t::u32>(element::f16, element::u32),
-        generateScatterUpdate3Params<element::Type_t::f16, element::Type_t::u64>(element::f16, element::u64),
+        generateScatterUpdate3Params<ov::element::Type_t::f16, ov::element::Type_t::i16>(ov::element::f16, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::f16, ov::element::Type_t::i32>(ov::element::f16, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::f16, ov::element::Type_t::i64>(ov::element::f16, ov::element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::f16, ov::element::Type_t::u32>(ov::element::f16, ov::element::u32),
+        generateScatterUpdate3Params<ov::element::Type_t::f16, ov::element::Type_t::u64>(ov::element::f16, ov::element::u64),
         // i8
-        generateScatterUpdate3Params<element::Type_t::i8, element::Type_t::i16>(element::i8, element::i16),
-        generateScatterUpdate3Params<element::Type_t::i8, element::Type_t::i32>(element::i8, element::i32),
-        generateScatterUpdate3Params<element::Type_t::i8, element::Type_t::i64>(element::i8, element::i64),
-        generateScatterUpdate3Params<element::Type_t::i8, element::Type_t::u32>(element::i8, element::u32),
-        generateScatterUpdate3Params<element::Type_t::i8, element::Type_t::u64>(element::i8, element::u64),
+        generateScatterUpdate3Params<ov::element::Type_t::i8, ov::element::Type_t::i16>(ov::element::i8, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::i8, ov::element::Type_t::i32>(ov::element::i8, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::i8, ov::element::Type_t::i64>(ov::element::i8, ov::element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::i8, ov::element::Type_t::u32>(ov::element::i8, ov::element::u32),
+        generateScatterUpdate3Params<ov::element::Type_t::i8, ov::element::Type_t::u64>(ov::element::i8, ov::element::u64),
         // i16
-        generateScatterUpdate3Params<element::Type_t::i16, element::Type_t::i16>(element::i16, element::i16),
-        generateScatterUpdate3Params<element::Type_t::i16, element::Type_t::i32>(element::i16, element::i32),
-        generateScatterUpdate3Params<element::Type_t::i16, element::Type_t::i64>(element::i16, element::i64),
-        generateScatterUpdate3Params<element::Type_t::i16, element::Type_t::u32>(element::i16, element::u32),
-        generateScatterUpdate3Params<element::Type_t::i16, element::Type_t::u64>(element::i16, element::u64),
+        generateScatterUpdate3Params<ov::element::Type_t::i16, ov::element::Type_t::i16>(ov::element::i16, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::i16, ov::element::Type_t::i32>(ov::element::i16, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::i16, ov::element::Type_t::i64>(ov::element::i16, ov::element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::i16, ov::element::Type_t::u32>(ov::element::i16, ov::element::u32),
+        generateScatterUpdate3Params<ov::element::Type_t::i16, ov::element::Type_t::u64>(ov::element::i16, ov::element::u64),
         // i32
-        generateScatterUpdate3Params<element::Type_t::i32, element::Type_t::i16>(element::i32, element::i16),
-        generateScatterUpdate3Params<element::Type_t::i32, element::Type_t::i32>(element::i32, element::i32),
-        generateScatterUpdate3Params<element::Type_t::i32, element::Type_t::i64>(element::i32, element::i64),
-        generateScatterUpdate3Params<element::Type_t::i32, element::Type_t::u32>(element::i32, element::u32),
-        generateScatterUpdate3Params<element::Type_t::i32, element::Type_t::u64>(element::i32, element::u64),
+        generateScatterUpdate3Params<ov::element::Type_t::i32, ov::element::Type_t::i16>(ov::element::i32, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::i32, ov::element::Type_t::i32>(ov::element::i32, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::i32, ov::element::Type_t::i64>(ov::element::i32, ov::element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::i32, ov::element::Type_t::u32>(ov::element::i32, ov::element::u32),
+        generateScatterUpdate3Params<ov::element::Type_t::i32, ov::element::Type_t::u64>(ov::element::i32, ov::element::u64),
         // i64
-        generateScatterUpdate3Params<element::Type_t::i64, element::Type_t::i16>(element::i64, element::i16),
-        generateScatterUpdate3Params<element::Type_t::i64, element::Type_t::i32>(element::i64, element::i32),
-        generateScatterUpdate3Params<element::Type_t::i64, element::Type_t::i64>(element::i64, element::i64),
-        generateScatterUpdate3Params<element::Type_t::i64, element::Type_t::u32>(element::i64, element::u32),
-        generateScatterUpdate3Params<element::Type_t::i64, element::Type_t::u64>(element::i64, element::u64),
+        generateScatterUpdate3Params<ov::element::Type_t::i64, ov::element::Type_t::i16>(ov::element::i64, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::i64, ov::element::Type_t::i32>(ov::element::i64, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::i64, ov::element::Type_t::i64>(ov::element::i64, ov::element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::i64, ov::element::Type_t::u32>(ov::element::i64, ov::element::u32),
+        generateScatterUpdate3Params<ov::element::Type_t::i64, ov::element::Type_t::u64>(ov::element::i64, ov::element::u64),
         // u8
-        generateScatterUpdate3Params<element::Type_t::u8, element::Type_t::i16>(element::u8, element::i16),
-        generateScatterUpdate3Params<element::Type_t::u8, element::Type_t::i32>(element::u8, element::i32),
-        generateScatterUpdate3Params<element::Type_t::u8, element::Type_t::i64>(element::u8, element::i64),
-        generateScatterUpdate3Params<element::Type_t::u8, element::Type_t::u32>(element::u8, element::u32),
-        generateScatterUpdate3Params<element::Type_t::u8, element::Type_t::u64>(element::u8, element::u64),
+        generateScatterUpdate3Params<ov::element::Type_t::u8, ov::element::Type_t::i16>(ov::element::u8, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::u8, ov::element::Type_t::i32>(ov::element::u8, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::u8, ov::element::Type_t::i64>(ov::element::u8, ov::element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::u8, ov::element::Type_t::u32>(ov::element::u8, ov::element::u32),
+        generateScatterUpdate3Params<ov::element::Type_t::u8, ov::element::Type_t::u64>(ov::element::u8, ov::element::u64),
         // u16
-        generateScatterUpdate3Params<element::Type_t::u16, element::Type_t::i16>(element::u16, element::i16),
-        generateScatterUpdate3Params<element::Type_t::u16, element::Type_t::i32>(element::u16, element::i32),
-        generateScatterUpdate3Params<element::Type_t::u16, element::Type_t::i64>(element::u16, element::i64),
-        generateScatterUpdate3Params<element::Type_t::u16, element::Type_t::u32>(element::u16, element::u32),
-        generateScatterUpdate3Params<element::Type_t::u16, element::Type_t::u64>(element::u16, element::u64),
+        generateScatterUpdate3Params<ov::element::Type_t::u16, ov::element::Type_t::i16>(ov::element::u16, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::u16, ov::element::Type_t::i32>(ov::element::u16, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::u16, ov::element::Type_t::i64>(ov::element::u16, ov::element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::u16, ov::element::Type_t::u32>(ov::element::u16, ov::element::u32),
+        generateScatterUpdate3Params<ov::element::Type_t::u16, ov::element::Type_t::u64>(ov::element::u16, ov::element::u64),
         // u32
-        generateScatterUpdate3Params<element::Type_t::u32, element::Type_t::i16>(element::u32, element::i16),
-        generateScatterUpdate3Params<element::Type_t::u32, element::Type_t::i32>(element::u32, element::i32),
-        generateScatterUpdate3Params<element::Type_t::u32, element::Type_t::i64>(element::u32, element::i64),
-        generateScatterUpdate3Params<element::Type_t::u32, element::Type_t::u32>(element::u32, element::u32),
-        generateScatterUpdate3Params<element::Type_t::u32, element::Type_t::u64>(element::u32, element::u64),
+        generateScatterUpdate3Params<ov::element::Type_t::u32, ov::element::Type_t::i16>(ov::element::u32, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::u32, ov::element::Type_t::i32>(ov::element::u32, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::u32, ov::element::Type_t::i64>(ov::element::u32, ov::element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::u32, ov::element::Type_t::u32>(ov::element::u32, ov::element::u32),
+        generateScatterUpdate3Params<ov::element::Type_t::u32, ov::element::Type_t::u64>(ov::element::u32, ov::element::u64),
         // u64
-        generateScatterUpdate3Params<element::Type_t::u64, element::Type_t::i16>(element::u64, element::i16),
-        generateScatterUpdate3Params<element::Type_t::u64, element::Type_t::i32>(element::u64, element::i32),
-        generateScatterUpdate3Params<element::Type_t::u64, element::Type_t::i64>(element::u64, element::i64),
-        generateScatterUpdate3Params<element::Type_t::u64, element::Type_t::u32>(element::u64, element::u32),
-        generateScatterUpdate3Params<element::Type_t::u64, element::Type_t::u64>(element::u64, element::u64),
+        generateScatterUpdate3Params<ov::element::Type_t::u64, ov::element::Type_t::i16>(ov::element::u64, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::u64, ov::element::Type_t::i32>(ov::element::u64, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::u64, ov::element::Type_t::i64>(ov::element::u64, ov::element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::u64, ov::element::Type_t::u32>(ov::element::u64, ov::element::u32),
+        generateScatterUpdate3Params<ov::element::Type_t::u64, ov::element::Type_t::u64>(ov::element::u64, ov::element::u64),
         // bf16
-        generateScatterUpdate3Params<element::Type_t::bf16, element::Type_t::i16>(element::bf16, element::i16),
-        generateScatterUpdate3Params<element::Type_t::bf16, element::Type_t::i32>(element::bf16, element::i32),
-        generateScatterUpdate3Params<element::Type_t::bf16, element::Type_t::i64>(element::bf16, element::i64),
-        generateScatterUpdate3Params<element::Type_t::bf16, element::Type_t::u32>(element::bf16, element::u32),
-        generateScatterUpdate3Params<element::Type_t::bf16, element::Type_t::u64>(element::bf16, element::u64)};
+        generateScatterUpdate3Params<ov::element::Type_t::bf16, ov::element::Type_t::i16>(ov::element::bf16, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::bf16, ov::element::Type_t::i32>(ov::element::bf16, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::bf16, ov::element::Type_t::i64>(ov::element::bf16, ov::element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::bf16, ov::element::Type_t::u32>(ov::element::bf16, ov::element::u32),
+        generateScatterUpdate3Params<ov::element::Type_t::bf16, ov::element::Type_t::u64>(ov::element::bf16, ov::element::u64)};
     std::vector<ScatterUpdate3Params> combinedParams;
 
     for (const auto& params : ScatterUpdateTypeParams) {
@@ -947,49 +942,49 @@ std::vector<ScatterUpdate3Params> generateScatterUpdateCombinedParams() {
 std::vector<ScatterUpdate3Params> generateScatterUpdateNegativeAxisParams() {
     const std::vector<std::vector<ScatterUpdate3Params>> ScatterUpdateTypeParams {
         // f32
-        generateScatterUpdate3Params<element::Type_t::f32, element::Type_t::i16>(element::f32, element::i16),
-        generateScatterUpdate3Params<element::Type_t::f32, element::Type_t::i32>(element::f32, element::i32),
-        generateScatterUpdate3Params<element::Type_t::f32, element::Type_t::i64>(element::f32, element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::f32, ov::element::Type_t::i16>(ov::element::f32, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::f32, ov::element::Type_t::i32>(ov::element::f32, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::f32, ov::element::Type_t::i64>(ov::element::f32, ov::element::i64),
         // f16
-        generateScatterUpdate3Params<element::Type_t::f16, element::Type_t::i16>(element::f16, element::i16),
-        generateScatterUpdate3Params<element::Type_t::f16, element::Type_t::i32>(element::f16, element::i32),
-        generateScatterUpdate3Params<element::Type_t::f16, element::Type_t::i64>(element::f16, element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::f16, ov::element::Type_t::i16>(ov::element::f16, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::f16, ov::element::Type_t::i32>(ov::element::f16, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::f16, ov::element::Type_t::i64>(ov::element::f16, ov::element::i64),
         // i8
-        generateScatterUpdate3Params<element::Type_t::i8, element::Type_t::i16>(element::i8, element::i16),
-        generateScatterUpdate3Params<element::Type_t::i8, element::Type_t::i32>(element::i8, element::i32),
-        generateScatterUpdate3Params<element::Type_t::i8, element::Type_t::i64>(element::i8, element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::i8, ov::element::Type_t::i16>(ov::element::i8, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::i8, ov::element::Type_t::i32>(ov::element::i8, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::i8, ov::element::Type_t::i64>(ov::element::i8, ov::element::i64),
         // i16
-        generateScatterUpdate3Params<element::Type_t::i16, element::Type_t::i16>(element::i16, element::i16),
-        generateScatterUpdate3Params<element::Type_t::i16, element::Type_t::i32>(element::i16, element::i32),
-        generateScatterUpdate3Params<element::Type_t::i16, element::Type_t::i64>(element::i16, element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::i16, ov::element::Type_t::i16>(ov::element::i16, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::i16, ov::element::Type_t::i32>(ov::element::i16, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::i16, ov::element::Type_t::i64>(ov::element::i16, ov::element::i64),
         // i32
-        generateScatterUpdate3Params<element::Type_t::i32, element::Type_t::i16>(element::i32, element::i16),
-        generateScatterUpdate3Params<element::Type_t::i32, element::Type_t::i32>(element::i32, element::i32),
-        generateScatterUpdate3Params<element::Type_t::i32, element::Type_t::i64>(element::i32, element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::i32, ov::element::Type_t::i16>(ov::element::i32, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::i32, ov::element::Type_t::i32>(ov::element::i32, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::i32, ov::element::Type_t::i64>(ov::element::i32, ov::element::i64),
         // i64
-        generateScatterUpdate3Params<element::Type_t::i64, element::Type_t::i16>(element::i64, element::i16),
-        generateScatterUpdate3Params<element::Type_t::i64, element::Type_t::i32>(element::i64, element::i32),
-        generateScatterUpdate3Params<element::Type_t::i64, element::Type_t::i64>(element::i64, element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::i64, ov::element::Type_t::i16>(ov::element::i64, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::i64, ov::element::Type_t::i32>(ov::element::i64, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::i64, ov::element::Type_t::i64>(ov::element::i64, ov::element::i64),
         // u8
-        generateScatterUpdate3Params<element::Type_t::u8, element::Type_t::i16>(element::u8, element::i16),
-        generateScatterUpdate3Params<element::Type_t::u8, element::Type_t::i32>(element::u8, element::i32),
-        generateScatterUpdate3Params<element::Type_t::u8, element::Type_t::i64>(element::u8, element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::u8, ov::element::Type_t::i16>(ov::element::u8, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::u8, ov::element::Type_t::i32>(ov::element::u8, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::u8, ov::element::Type_t::i64>(ov::element::u8, ov::element::i64),
         // u16
-        generateScatterUpdate3Params<element::Type_t::u16, element::Type_t::i16>(element::u16, element::i16),
-        generateScatterUpdate3Params<element::Type_t::u16, element::Type_t::i32>(element::u16, element::i32),
-        generateScatterUpdate3Params<element::Type_t::u16, element::Type_t::i64>(element::u16, element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::u16, ov::element::Type_t::i16>(ov::element::u16, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::u16, ov::element::Type_t::i32>(ov::element::u16, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::u16, ov::element::Type_t::i64>(ov::element::u16, ov::element::i64),
         // u32
-        generateScatterUpdate3Params<element::Type_t::u32, element::Type_t::i16>(element::u32, element::i16),
-        generateScatterUpdate3Params<element::Type_t::u32, element::Type_t::i32>(element::u32, element::i32),
-        generateScatterUpdate3Params<element::Type_t::u32, element::Type_t::i64>(element::u32, element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::u32, ov::element::Type_t::i16>(ov::element::u32, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::u32, ov::element::Type_t::i32>(ov::element::u32, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::u32, ov::element::Type_t::i64>(ov::element::u32, ov::element::i64),
         // u64
-        generateScatterUpdate3Params<element::Type_t::u64, element::Type_t::i16>(element::u64, element::i16),
-        generateScatterUpdate3Params<element::Type_t::u64, element::Type_t::i32>(element::u64, element::i32),
-        generateScatterUpdate3Params<element::Type_t::u64, element::Type_t::i64>(element::u64, element::i64),
+        generateScatterUpdate3Params<ov::element::Type_t::u64, ov::element::Type_t::i16>(ov::element::u64, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::u64, ov::element::Type_t::i32>(ov::element::u64, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::u64, ov::element::Type_t::i64>(ov::element::u64, ov::element::i64),
         // bf16
-        generateScatterUpdate3Params<element::Type_t::bf16, element::Type_t::i16>(element::bf16, element::i16),
-        generateScatterUpdate3Params<element::Type_t::bf16, element::Type_t::i32>(element::bf16, element::i32),
-        generateScatterUpdate3Params<element::Type_t::bf16, element::Type_t::i64>(element::bf16, element::i64)};
+        generateScatterUpdate3Params<ov::element::Type_t::bf16, ov::element::Type_t::i16>(ov::element::bf16, ov::element::i16),
+        generateScatterUpdate3Params<ov::element::Type_t::bf16, ov::element::Type_t::i32>(ov::element::bf16, ov::element::i32),
+        generateScatterUpdate3Params<ov::element::Type_t::bf16, ov::element::Type_t::i64>(ov::element::bf16, ov::element::i64)};
     std::vector<ScatterUpdate3Params> combinedParams;
 
     for (const auto& params : ScatterUpdateTypeParams) {
diff --git a/src/plugins/template/tests/functional/op_reference/sin.cpp b/src/plugins/template/tests/functional/op_reference/sin.cpp
index 2fcc6701366..0db13c355a1 100644
--- a/src/plugins/template/tests/functional/op_reference/sin.cpp
+++ b/src/plugins/template/tests/functional/op_reference/sin.cpp
@@ -56,8 +56,8 @@ INSTANTIATE_TEST_SUITE_P(
     smoke_Sin_With_Hardcoded_Refs, ReferenceSinLayerTest,
     ::testing::Values(
         Builder {}
-            .input({{11}, element::f16, std::vector<ngraph::float16> {0.f, 0.25f, -0.25f, 0.5f, -0.5f, 1.f, -1.f, 2.f, -2.f, 4.f, -4.f}})
-            .expected({{11}, element::f16, std::vector<ngraph::float16> {0.00000000f,
+            .input({{11}, element::f16, std::vector<ov::float16> {0.f, 0.25f, -0.25f, 0.5f, -0.5f, 1.f, -1.f, 2.f, -2.f, 4.f, -4.f}})
+            .expected({{11}, element::f16, std::vector<ov::float16> {0.00000000f,
                                 0.24740396f,
                                 -0.24740396f,
                                 0.47942554f,
diff --git a/src/plugins/template/tests/functional/op_reference/sinh.cpp b/src/plugins/template/tests/functional/op_reference/sinh.cpp
index 31e309ca85b..c93c6eb5c72 100644
--- a/src/plugins/template/tests/functional/op_reference/sinh.cpp
+++ b/src/plugins/template/tests/functional/op_reference/sinh.cpp
@@ -56,8 +56,8 @@ INSTANTIATE_TEST_SUITE_P(
     smoke_Sinh_With_Hardcoded_Refs, ReferenceSinhLayerTest,
     ::testing::Values(
         Builder {}
-            .input({{11}, element::f16, std::vector<ngraph::float16> {-4.f, -2.f, -1.f, -0.5f, -0.25f, 0.f, 0.25f, 0.5f, 1.f, 2.f, 4.f}})
-            .expected({{11}, element::f16, std::vector<ngraph::float16> {-27.28991720f,
+            .input({{11}, element::f16, std::vector<ov::float16> {-4.f, -2.f, -1.f, -0.5f, -0.25f, 0.f, 0.25f, 0.5f, 1.f, 2.f, 4.f}})
+            .expected({{11}, element::f16, std::vector<ov::float16> {-27.28991720f,
                             -3.62686041f,
                             -1.17520120f,
                             -0.52109531f,
diff --git a/src/plugins/template/tests/functional/op_reference/tanh.cpp b/src/plugins/template/tests/functional/op_reference/tanh.cpp
index c481a0d62b3..da0f8303d4c 100644
--- a/src/plugins/template/tests/functional/op_reference/tanh.cpp
+++ b/src/plugins/template/tests/functional/op_reference/tanh.cpp
@@ -56,8 +56,8 @@ INSTANTIATE_TEST_SUITE_P(
     smoke_Tanh_With_Hardcoded_Refs, ReferenceTanhLayerTest,
     ::testing::Values(
         Builder {}
-            .input({{11}, element::f16, std::vector<ngraph::float16> {-4.f, -2.f, -1.f, -0.5f, -0.25f, 0.f, 0.25f, 0.5f, 1.f, 2.f, 4.f}})
-            .expected({{11}, element::f16, std::vector<ngraph::float16> {-0.99932930f,
+            .input({{11}, element::f16, std::vector<ov::float16> {-4.f, -2.f, -1.f, -0.5f, -0.25f, 0.f, 0.25f, 0.5f, 1.f, 2.f, 4.f}})
+            .expected({{11}, element::f16, std::vector<ov::float16> {-0.99932930f,
                             -0.96402758f,
                             -0.76159416f,
                             -0.46211716f,
diff --git a/src/plugins/template/tests/functional/op_reference/tensor_iterator.cpp b/src/plugins/template/tests/functional/op_reference/tensor_iterator.cpp
index 2f6faaa853d..1caa12dff5c 100644
--- a/src/plugins/template/tests/functional/op_reference/tensor_iterator.cpp
+++ b/src/plugins/template/tests/functional/op_reference/tensor_iterator.cpp
@@ -10,8 +10,6 @@
 #include "base_reference_test.hpp"
 #include "functional_test_utils/skip_tests_config.hpp"
 
-#include "ngraph_functions/builders.hpp"
-
 namespace {
 struct TIFunctionalBase {
     virtual std::shared_ptr<ov::Model> create_function(const std::vector<reference_tests::Tensor> &ti_inputs,
@@ -36,8 +34,8 @@ struct TIDynamicInputs : public TIFunctionalBase {
         auto M_body = std::make_shared<ov::opset8::Parameter>(ov::element::f32, ov::PartialShape::dynamic());
         auto body_condition = std::make_shared<ov::opset8::Constant>(ov::element::boolean, ov::Shape{1}, true);
 
-        auto trip_count = std::make_shared<ov::opset8::Constant>(ngraph::element::i64, ov::Shape{1}, 3);
-        auto exec_condition = std::make_shared<ov::opset8::Constant>(ngraph::element::boolean, ov::Shape{1}, true);
+        auto trip_count = std::make_shared<ov::opset8::Constant>(ov::element::i64, ov::Shape{1}, 3);
+        auto exec_condition = std::make_shared<ov::opset8::Constant>(ov::element::boolean, ov::Shape{1}, true);
         // Body
         auto sum = std::make_shared<ov::opset8::Add>(Xi, Yi);
         auto Zo = std::make_shared<ov::opset8::Multiply>(sum, M_body);
@@ -297,7 +295,7 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
                 ov::ResultVector results{std::make_shared<ov::opset8::Result>(unsqueeze),
                                              std::make_shared<ov::opset8::Result>(lstm_cell->output(0)),
                                              std::make_shared<ov::opset8::Result>(lstm_cell->output(1))};
-                auto body = std::make_shared<ngraph::Function>(results, body_params, "lstm_cell");
+                auto body = std::make_shared<ov::Model>(results, body_params, "lstm_cell");
                 tensor_iterator->set_function(body);
 
                 // 2. Set PortMap
@@ -308,7 +306,7 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
                     tensor_iterator->set_sliced_input(body_params[0], outer_params[0], -1, -1, 1, 0, params.sequenceAxis);
                     tensor_iterator->get_concatenated_slices(results[0], -1, -1, 1, 0, params.sequenceAxis);
                 } else {
-                    NGRAPH_CHECK(false, "Bidirectional case is not supported.");
+                    OPENVINO_ASSERT(false, "Bidirectional case is not supported.");
                 }
 
                 tensor_iterator->set_merged_input(body_params[1], outer_params[1], results[1]);
@@ -317,7 +315,7 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
                 tensor_iterator->get_iter_value(results[2]);
 
                 // 3. Outer function
-                function = std::make_shared<ngraph::Function>(ngraph::OutputVector{tensor_iterator->output(0), tensor_iterator->output(1),
+                function = std::make_shared<ov::Model>(ov::OutputVector{tensor_iterator->output(0), tensor_iterator->output(1),
                                                                                    tensor_iterator->output(2)}, outer_params);
                 break;
             }
@@ -342,7 +340,7 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
                                                 std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[1])};
 
                 auto squeeze = std::make_shared<ov::opset8::Squeeze>(body_params[0], axis);
-                ngraph::OutputVector out_vector = {squeeze, body_params[1]};
+                ov::OutputVector out_vector = {squeeze, body_params[1]};
 
                 auto W = std::make_shared<ov::opset8::Constant>(params.W.type, params.W.shape, params.W.data.data());
                 auto R = std::make_shared<ov::opset8::Constant>(params.R.type, params.R.shape, params.R.data.data());
@@ -360,9 +358,9 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
                                                                           false);
 
                 auto unsqueeze = std::make_shared<ov::opset8::Unsqueeze>(gru_cell->output(0), axis);
-                ngraph::ResultVector results{std::make_shared<ov::opset8::Result>(gru_cell->output(0)),
+                ov::ResultVector results{std::make_shared<ov::opset8::Result>(gru_cell->output(0)),
                                              std::make_shared<ov::opset8::Result>(unsqueeze)};
-                auto body = std::make_shared<ngraph::Function>(results, body_params, "gru_cell");
+                auto body = std::make_shared<ov::Model>(results, body_params, "gru_cell");
                 tensor_iterator->set_function(body);
 
                 // 2. Set PortMap
@@ -373,14 +371,14 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
                     tensor_iterator->set_sliced_input(body_params[0], outer_params[0], -1, -1, 1, 0, params.sequenceAxis);
                     tensor_iterator->get_concatenated_slices(results[1], -1, -1, 1, 0, params.sequenceAxis);
                 } else {
-                    NGRAPH_CHECK(false, "Bidirectional case is not supported.");
+                    OPENVINO_ASSERT(false, "Bidirectional case is not supported.");
                 }
 
                 tensor_iterator->set_merged_input(body_params[1], outer_params[1], results[0]);
                 tensor_iterator->get_iter_value(results[0]);
 
                 // 3. Outer function
-                function = std::make_shared<ngraph::Function>(ngraph::OutputVector{tensor_iterator->output(0), tensor_iterator->output(1)}, outer_params);
+                function = std::make_shared<ov::Model>(ov::OutputVector{tensor_iterator->output(0), tensor_iterator->output(1)}, outer_params);
                 break;
             }
             case TensorIteratorBodyType::RNN: {
@@ -403,7 +401,7 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
                 ov::ParameterVector body_params{std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[0]),
                                                 std::make_shared<ov::op::v0::Parameter>(params.iType, inputShapes[1])};
                 auto squeeze = std::make_shared<ov::opset8::Squeeze>(body_params[0], axis);
-                ngraph::OutputVector out_vector = {squeeze, body_params[1]};
+                ov::OutputVector out_vector = {squeeze, body_params[1]};
 
                 auto W = std::make_shared<ov::opset8::Constant>(params.W.type, params.W.shape, params.W.data.data());
                 auto R = std::make_shared<ov::opset8::Constant>(params.R.type, params.R.shape, params.R.data.data());
@@ -420,9 +418,9 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
                                                                           params.clip);
 
                 auto unsqueeze = std::make_shared<ov::opset8::Unsqueeze>(rnn_cell->output(0), axis);
-                ngraph::ResultVector results{std::make_shared<ov::opset8::Result>(rnn_cell),
+                ov::ResultVector results{std::make_shared<ov::opset8::Result>(rnn_cell),
                                              std::make_shared<ov::opset8::Result>(unsqueeze)};
-                auto body = std::make_shared<ngraph::Function>(results, body_params, "rnn_cell");
+                auto body = std::make_shared<ov::Model>(results, body_params, "rnn_cell");
                 tensor_iterator->set_function(body);
 
                 // 2. Set PortMap
@@ -433,14 +431,14 @@ struct TIStaticInputs : public TIStaticFunctionalBase {
                     tensor_iterator->set_sliced_input(body_params[0], outer_params[0], -1, -1, 1, 0, params.sequenceAxis);
                     tensor_iterator->get_concatenated_slices(results[1], -1, -1, 1, 0, params.sequenceAxis);
                 } else {
-                    NGRAPH_CHECK(false, "Bidirectional case is not supported.");
+                    OPENVINO_ASSERT(false, "Bidirectional case is not supported.");
                 }
 
                 tensor_iterator->set_merged_input(body_params[1], outer_params[1], results[0]);
                 tensor_iterator->get_iter_value(results[0]);
 
                 // 3. Outer function
-                function = std::make_shared<ngraph::Function>(ngraph::OutputVector{tensor_iterator->output(0), tensor_iterator->output(1)}, outer_params);
+                function = std::make_shared<ov::Model>(ov::OutputVector{tensor_iterator->output(0), tensor_iterator->output(1)}, outer_params);
                 break;
             }
         }
diff --git a/src/plugins/template/tests/functional/op_reference/topk.cpp b/src/plugins/template/tests/functional/op_reference/topk.cpp
index d30b9ecbd76..74291ea086f 100644
--- a/src/plugins/template/tests/functional/op_reference/topk.cpp
+++ b/src/plugins/template/tests/functional/op_reference/topk.cpp
@@ -1479,18 +1479,18 @@ INSTANTIATE_TEST_SUITE_P(smoke_TopK_With_Hardcoded_Refs, ReferenceTopKTestSingle
 TEST(ReferenceTopKTestInvalid, topk_v1_invalid_strings) {
     const auto data = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 2, 3});
     const auto k = opset1::Constant::create(element::i64, Shape{}, {1});
-    EXPECT_THROW(opset1::TopK(data, k, 0, "max", "invalid_mode"), ngraph::CheckFailure);
-    EXPECT_THROW(opset1::TopK(data, k, 0, "invalid_sort", "index"), ngraph::CheckFailure);
+    EXPECT_THROW(opset1::TopK(data, k, 0, "max", "invalid_mode"), ov::AssertFailure);
+    EXPECT_THROW(opset1::TopK(data, k, 0, "invalid_sort", "index"), ov::AssertFailure);
 }
 
 TEST(ReferenceTopKTestInvalid, topk_v1_invalid_k) {
     const auto data = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 2, 3});
     const auto k_non_scalar = opset1::Constant::create(element::i64, Shape{2}, {1, 2});
-    EXPECT_THROW(opset1::TopK(data, k_non_scalar, 0, "max", "index"), ngraph::NodeValidationFailure);
+    EXPECT_THROW(opset1::TopK(data, k_non_scalar, 0, "max", "index"), ov::NodeValidationFailure);
     const auto k_float = opset1::Constant::create(element::f32, Shape{}, {1.0f});
-    EXPECT_THROW(opset1::TopK(data, k_float, 0, "max", "index"), ngraph::NodeValidationFailure);
+    EXPECT_THROW(opset1::TopK(data, k_float, 0, "max", "index"), ov::NodeValidationFailure);
     const auto k_negative = opset1::Constant::create(element::i8, Shape{}, {-1});
-    EXPECT_THROW(opset1::TopK(data, k_negative, 0, "max", "index"), ngraph::NodeValidationFailure);
+    EXPECT_THROW(opset1::TopK(data, k_negative, 0, "max", "index"), ov::NodeValidationFailure);
 }
 
 
@@ -1641,18 +1641,18 @@ INSTANTIATE_TEST_SUITE_P(smoke_TopK_With_Hardcoded_Refs, ReferenceTopKTestSingle
 TEST(ReferenceTopKTestInvalidV3, topk_v3_invalid_strings) {
     const auto data = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 2, 3});
     const auto k = opset1::Constant::create(element::i64, Shape{}, {1});
-    EXPECT_THROW(opset3::TopK(data, k, 0, "max", "invalid_mode"), ngraph::CheckFailure);
-    EXPECT_THROW(opset3::TopK(data, k, 0, "invalid_sort", "index"), ngraph::CheckFailure);
+    EXPECT_THROW(opset3::TopK(data, k, 0, "max", "invalid_mode"), ov::AssertFailure);
+    EXPECT_THROW(opset3::TopK(data, k, 0, "invalid_sort", "index"), ov::AssertFailure);
 }
 
 TEST(ReferenceTopKTestInvalidV3, topk_v3_invalid_k) {
     const auto data = std::make_shared<opset1::Parameter>(element::f32, Shape{1, 2, 3});
     const auto k_non_scalar = opset1::Constant::create(element::i64, Shape{2}, {1, 2});
-    EXPECT_THROW(opset3::TopK(data, k_non_scalar, 0, "max", "index"), ngraph::NodeValidationFailure);
+    EXPECT_THROW(opset3::TopK(data, k_non_scalar, 0, "max", "index"), ov::NodeValidationFailure);
     const auto k_float = opset1::Constant::create(element::f32, Shape{}, {1.0f});
-    EXPECT_THROW(opset3::TopK(data, k_float, 0, "max", "index"), ngraph::NodeValidationFailure);
+    EXPECT_THROW(opset3::TopK(data, k_float, 0, "max", "index"), ov::NodeValidationFailure);
     const auto k_negative = opset1::Constant::create(element::i8, Shape{}, {-1});
-    EXPECT_THROW(opset3::TopK(data, k_negative, 0, "max", "index"), ngraph::NodeValidationFailure);
+    EXPECT_THROW(opset3::TopK(data, k_negative, 0, "max", "index"), ov::NodeValidationFailure);
 }
 
 class ReferenceTopKv11StableTest : public ReferenceTopKTest {
diff --git a/src/tests/test_utils/common_test_utils/include/common_test_utils/test_enums.hpp b/src/tests/test_utils/common_test_utils/include/common_test_utils/test_enums.hpp
new file mode 100644
index 00000000000..f96ae67fc3a
--- /dev/null
+++ b/src/tests/test_utils/common_test_utils/include/common_test_utils/test_enums.hpp
@@ -0,0 +1,42 @@
+// Copyright (C) 2018-2023 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+namespace ov {
+namespace test {
+namespace utils {
+
+enum ComparisonTypes {
+    EQUAL,
+    NOT_EQUAL,
+    IS_FINITE,
+    IS_INF,
+    IS_NAN,
+    LESS,
+    LESS_EQUAL,
+    GREATER,
+    GREATER_EQUAL
+};
+
+enum ConversionTypes {
+    CONVERT,
+    CONVERT_LIKE
+};
+
+enum ReductionType {
+    Mean,
+    Max,
+    Min,
+    Prod,
+    Sum,
+    LogicalOr,
+    LogicalAnd,
+    L1,
+    L2
+};
+
+}  // namespace utils
+}  // namespace test
+}  // namespace ov