diff --git a/docs/template_plugin/tests/functional/op_reference/acos.cpp b/docs/template_plugin/tests/functional/op_reference/acos.cpp
index a3d66bc1b0e..15e04a82081 100644
--- a/docs/template_plugin/tests/functional/op_reference/acos.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/acos.cpp
@@ -4,15 +4,10 @@
 
 #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 "openvino/op/acos.hpp"
 #include "base_reference_test.hpp"
 
-using namespace ngraph;
+using namespace ov;
 
 namespace reference_tests {
 namespace {
@@ -45,8 +40,8 @@ public:
 
 private:
     static std::shared_ptr<Function> CreateFunction(const Shape& shape, const element::Type& type) {
-        const auto in = std::make_shared<op::Parameter>(type, shape);
-        const auto acos = std::make_shared<op::Acos>(in);
+        const auto in = std::make_shared<op::v0::Parameter>(type, shape);
+        const auto acos = std::make_shared<op::v0::Acos>(in);
         return std::make_shared<Function>(NodeVector {acos}, ParameterVector {in});
     }
 };
diff --git a/docs/template_plugin/tests/functional/op_reference/acosh.cpp b/docs/template_plugin/tests/functional/op_reference/acosh.cpp
index 4bf66df4a14..6096b6b200d 100644
--- a/docs/template_plugin/tests/functional/op_reference/acosh.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/acosh.cpp
@@ -4,12 +4,10 @@
 
 #include <gtest/gtest.h>
 
-#include <shared_test_classes/base/layer_test_utils.hpp>
-#include <vector>
-
+#include "openvino/op/acosh.hpp"
 #include "base_reference_test.hpp"
 
-using namespace ngraph;
+using namespace ov;
 
 namespace reference_tests {
 namespace {
@@ -42,9 +40,9 @@ public:
 
 private:
     static std::shared_ptr<Function> CreateFunction(const Shape& shape, const element::Type& type) {
-        const auto in = std::make_shared<op::Parameter>(type, shape);
-        const auto acosh = std::make_shared<op::Acosh>(in);
-        return std::make_shared<Function>(NodeVector {acosh}, ParameterVector {in});
+        const auto in = std::make_shared<op::v0::Parameter>(type, shape);
+        const auto acosh = std::make_shared<op::v3::Acosh>(in);
+        return std::make_shared<ov::Function>(NodeVector {acosh}, ParameterVector {in});
     }
 };
 
diff --git a/docs/template_plugin/tests/functional/op_reference/asin.cpp b/docs/template_plugin/tests/functional/op_reference/asin.cpp
index d8a436f7d67..0670d108cee 100644
--- a/docs/template_plugin/tests/functional/op_reference/asin.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/asin.cpp
@@ -4,15 +4,11 @@
 
 #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 "openvino/op/asin.hpp"
+#include "shared_test_classes/base/layer_test_utils.hpp"
 #include "base_reference_test.hpp"
 
-using namespace ngraph;
+using namespace ov;
 
 namespace reference_tests {
 namespace {
@@ -45,9 +41,9 @@ public:
 
 private:
     static std::shared_ptr<Function> CreateFunction(const Shape& shape, const element::Type& type) {
-        const auto in = std::make_shared<op::Parameter>(type, shape);
-        const auto Asin = std::make_shared<op::Asin>(in);
-        return std::make_shared<Function>(NodeVector {Asin}, ParameterVector {in});
+        const auto in = std::make_shared<op::v0::Parameter>(type, shape);
+        const auto Asin = std::make_shared<op::v0::Asin>(in);
+        return std::make_shared<ov::Function>(NodeVector {Asin}, ParameterVector {in});
     }
 };
 
diff --git a/docs/template_plugin/tests/functional/op_reference/asinh.cpp b/docs/template_plugin/tests/functional/op_reference/asinh.cpp
index aca417ac643..7a6a0a4bfc7 100644
--- a/docs/template_plugin/tests/functional/op_reference/asinh.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/asinh.cpp
@@ -4,15 +4,11 @@
 
 #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 "openvino/op/asinh.hpp"
+#include "shared_test_classes/base/layer_test_utils.hpp"
 #include "base_reference_test.hpp"
 
-using namespace ngraph;
+using namespace ov;
 
 namespace reference_tests {
 namespace {
@@ -45,9 +41,9 @@ public:
 
 private:
     static std::shared_ptr<Function> CreateFunction(const Shape& shape, const element::Type& type) {
-        const auto in = std::make_shared<op::Parameter>(type, shape);
-        const auto Asinh = std::make_shared<op::Asinh>(in);
-        return std::make_shared<Function>(NodeVector {Asinh}, ParameterVector {in});
+        const auto in = std::make_shared<op::v0::Parameter>(type, shape);
+        const auto Asinh = std::make_shared<op::v3::Asinh>(in);
+        return std::make_shared<ov::Function>(NodeVector {Asinh}, ParameterVector {in});
     }
 };
 
diff --git a/docs/template_plugin/tests/functional/op_reference/atan.cpp b/docs/template_plugin/tests/functional/op_reference/atan.cpp
index 76f1edd74f6..ff43b52ddd7 100644
--- a/docs/template_plugin/tests/functional/op_reference/atan.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/atan.cpp
@@ -4,15 +4,10 @@
 
 #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 "openvino/op/atan.hpp"
 #include "base_reference_test.hpp"
 
-using namespace ngraph;
+using namespace ov;
 
 namespace reference_tests {
 namespace {
@@ -45,9 +40,9 @@ public:
 
 private:
     static std::shared_ptr<Function> CreateFunction(const Shape& shape, const element::Type& type) {
-        const auto in = std::make_shared<op::Parameter>(type, shape);
-        const auto atan = std::make_shared<op::Atan>(in);
-        return std::make_shared<Function>(NodeVector{atan}, ParameterVector{in});
+        const auto in = std::make_shared<op::v0::Parameter>(type, shape);
+        const auto atan = std::make_shared<op::v0::Atan>(in);
+        return std::make_shared<ov::Function>(NodeVector{atan}, ParameterVector{in});
     }
 };
 
diff --git a/docs/template_plugin/tests/functional/op_reference/atanh.cpp b/docs/template_plugin/tests/functional/op_reference/atanh.cpp
index 12fd26970bd..d3560e8ec23 100644
--- a/docs/template_plugin/tests/functional/op_reference/atanh.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/atanh.cpp
@@ -3,25 +3,19 @@
 //
 
 #include <gtest/gtest.h>
-
-#include <ie_core.hpp>
-#include <ie_ngraph_utils.hpp>
 #include <limits>
-#include <algorithm>
-#include <ngraph/ngraph.hpp>
-#include <shared_test_classes/base/layer_test_utils.hpp>
 
+#include "openvino/op/atanh.hpp"
 #include "base_reference_test.hpp"
 #include "openvino/runtime/allocator.hpp"
 
 using namespace reference_tests;
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 
 struct AtanhParams {
     template <class IT>
-    AtanhParams(const ngraph::PartialShape& shape, const ngraph::element::Type& iType, const std::vector<IT>& iValues)
-        : pshape(shape), inType(iType), outType(iType), inputData(CreateBlob(iType, iValues)) {
+    AtanhParams(const ov::PartialShape& shape, const ov::element::Type& iType, const std::vector<IT>& iValues)
+        : pshape(shape), inType(iType), outType(iType), inputData(CreateTensor(iType, iValues)) {
         std::vector<IT> oValues;
         std::vector<double> output;
         for (auto element : iValues)
@@ -39,11 +33,11 @@ struct AtanhParams {
 
         for (auto element : output)
             oValues.push_back(static_cast<IT>(element));
-        refData = CreateBlob(outType, oValues);
+        refData = CreateTensor(outType, oValues);
     }
-    ngraph::PartialShape pshape;
-    ngraph::element::Type inType;
-    ngraph::element::Type outType;
+    ov::PartialShape pshape;
+    ov::element::Type inType;
+    ov::element::Type outType;
     ov::runtime::Tensor inputData;
     ov::runtime::Tensor refData;
 };
@@ -68,9 +62,9 @@ public:
 private:
     static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
                                                     const element::Type& expected_output_type) {
-        const auto in = std::make_shared<op::Parameter>(input_type, input_shape);
-        const auto atanh = std::make_shared<op::Atanh>(in);
-        return std::make_shared<Function>(NodeVector {atanh}, ParameterVector {in});
+        const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
+        const auto atanh = std::make_shared<op::v3::Atanh>(in);
+        return std::make_shared<ov::Function>(NodeVector {atanh}, ParameterVector {in});
     }
 };
 
@@ -80,16 +74,16 @@ TEST_P(ReferenceAtanhLayerTest, CompareWithRefs) {
 
 INSTANTIATE_TEST_SUITE_P(
     smoke_Atanh_With_Hardcoded_Refs, ReferenceAtanhLayerTest,
-    ::testing::Values(AtanhParams(ngraph::PartialShape {2, 4}, ngraph::element::f32,
+    ::testing::Values(AtanhParams(ov::PartialShape {2, 4}, ov::element::f32,
                                 std::vector<float> {-INFINITY, -2.0f, -1.0f, -0.5f, 0.0f, 0.8f, 1.0f, INFINITY}),
-                      AtanhParams(ngraph::PartialShape {2, 4}, ngraph::element::f16,
+                      AtanhParams(ov::PartialShape {2, 4}, ov::element::f16,
                                 std::vector<float16> {-INFINITY, -2.0f, -1.0f, -0.5f, -0.0f, 0.8f, 1.0f, INFINITY}),
-                      AtanhParams(ngraph::PartialShape {2, 3}, ngraph::element::i32,
+                      AtanhParams(ov::PartialShape {2, 3}, ov::element::i32,
                                 std::vector<int32_t> {std::numeric_limits<int32_t>::min(), -2, -1, 1, 2, std::numeric_limits<int32_t>::max()}),
-                      AtanhParams(ngraph::PartialShape {2, 3}, ngraph::element::u32,
+                      AtanhParams(ov::PartialShape {2, 3}, ov::element::u32,
                                 std::vector<uint32_t> {std::numeric_limits<uint32_t>::min(), 0, 1, 2, 3, std::numeric_limits<uint32_t>::max()}),
-                      AtanhParams(ngraph::PartialShape {2, 3}, ngraph::element::i64,
+                      AtanhParams(ov::PartialShape {2, 3}, ov::element::i64,
                                 std::vector<int64_t> {std::numeric_limits<int64_t>::min(), -2, -1, 1, 2, std::numeric_limits<int64_t>::max()}),
-                      AtanhParams(ngraph::PartialShape {2, 3}, ngraph::element::u64,
+                      AtanhParams(ov::PartialShape {2, 3}, ov::element::u64,
                                 std::vector<uint64_t> {std::numeric_limits<uint64_t>::min(), 0, 1, 2, 3, std::numeric_limits<uint64_t>::max()})),
     ReferenceAtanhLayerTest::getTestCaseName);
diff --git a/docs/template_plugin/tests/functional/op_reference/base_reference_test.cpp b/docs/template_plugin/tests/functional/op_reference/base_reference_test.cpp
index ceb902b7c30..a41c2ac4363 100644
--- a/docs/template_plugin/tests/functional/op_reference/base_reference_test.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/base_reference_test.cpp
@@ -3,6 +3,7 @@
 //
 #include "base_reference_test.hpp"
 #include "functional_test_utils/ov_plugin_cache.hpp"
+#include "shared_test_classes/base/layer_test_utils.hpp"
 
 #include <gtest/gtest.h>
 
@@ -11,7 +12,7 @@
 #include "openvino/runtime/tensor.hpp"
 #include "transformations/utils/utils.hpp"
 
-using namespace InferenceEngine;
+using namespace ov;
 
 namespace reference_tests {
 
diff --git a/docs/template_plugin/tests/functional/op_reference/base_reference_test.hpp b/docs/template_plugin/tests/functional/op_reference/base_reference_test.hpp
index 49213892e51..e7869677434 100644
--- a/docs/template_plugin/tests/functional/op_reference/base_reference_test.hpp
+++ b/docs/template_plugin/tests/functional/op_reference/base_reference_test.hpp
@@ -2,15 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <ngraph/ngraph.hpp>
 #include "openvino/core/shape.hpp"
 #include "openvino/runtime/allocator.hpp"
 #include "openvino/runtime/tensor.hpp"
 #include "openvino/runtime/core.hpp"
 #include "openvino/core/type/element_type.hpp"
 
-#include <shared_test_classes/base/layer_test_utils.hpp>
-
 namespace reference_tests {
 
 class CommonReferenceTest {
@@ -18,13 +15,9 @@ public:
     CommonReferenceTest();
 
     void Exec();
-
     void LoadNetwork();
-
     void FillInputs();
-
     void Infer();
-
     void Validate();
 
 private:
@@ -43,7 +36,7 @@ protected:
 };
 
 template <class T>
-ov::runtime::Tensor CreateBlob(const ov::element::Type& element_type, const std::vector<T>& values, size_t size = 0) {
+ov::runtime::Tensor CreateTensor(const ov::element::Type& element_type, const std::vector<T>& values, size_t size = 0) {
     size_t real_size = size ? size : values.size() * sizeof(T) / element_type.size();
     ov::runtime::Tensor tensor { element_type, {real_size} };
     std::memcpy(tensor.data(), values.data(), std::min(real_size * element_type.size(), sizeof(T) * values.size()));
@@ -61,7 +54,7 @@ struct Tensor {
 
     template <typename T>
     Tensor(const ov::Shape& shape, ov::element::Type type, const std::vector<T>& data_elements)
-        : Tensor {shape, type, CreateBlob(type, data_elements)} {}
+        : Tensor {shape, type, CreateTensor(type, data_elements)} {}
 
     ov::Shape shape;
     ov::element::Type type;
diff --git a/docs/template_plugin/tests/functional/op_reference/comparison.hpp b/docs/template_plugin/tests/functional/op_reference/comparison.hpp
index ec8509de4c8..b25f3ef33a5 100644
--- a/docs/template_plugin/tests/functional/op_reference/comparison.hpp
+++ b/docs/template_plugin/tests/functional/op_reference/comparison.hpp
@@ -4,15 +4,11 @@
 
 #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"
 
+using namespace ov;
+
 namespace reference_tests {
 namespace ComparisonOpsRefTestDefinitions {
 
@@ -50,13 +46,13 @@ public:
     }
 
 private:
-    static std::shared_ptr<ngraph::Function> CreateFunction(ngraph::helpers::ComparisonTypes comp_op_type, const ngraph::PartialShape& input_shape1,
-                                                            const ngraph::PartialShape& input_shape2, const ngraph::element::Type& input_type,
-                                                            const ngraph::element::Type& expected_output_type) {
-        const auto in = std::make_shared<ngraph::op::Parameter>(input_type, input_shape1);
-        const auto in2 = std::make_shared<ngraph::op::Parameter>(input_type, input_shape2);
+    static std::shared_ptr<ov::Function> CreateFunction(ngraph::helpers::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<ngraph::Function>(ngraph::NodeVector {comp}, ngraph::ParameterVector {in, in2});
+        return std::make_shared<ov::Function>(ov::NodeVector {comp}, ov::ParameterVector {in, in2});
     }
 };
 }  // namespace ComparisonOpsRefTestDefinitions
diff --git a/docs/template_plugin/tests/functional/op_reference/conversion.hpp b/docs/template_plugin/tests/functional/op_reference/conversion.hpp
index 22869c08076..2e21ff1da0b 100644
--- a/docs/template_plugin/tests/functional/op_reference/conversion.hpp
+++ b/docs/template_plugin/tests/functional/op_reference/conversion.hpp
@@ -4,15 +4,11 @@
 
 #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"
 
+using namespace ov;
+
 namespace reference_tests {
 namespace ConversionOpsRefTestDefinitions {
 
@@ -23,14 +19,14 @@ static std::map<ngraph::helpers::ConversionTypes, std::string> conversionNames =
 
 struct ConvertParams {
     template <class IT, class OT>
-    ConvertParams(ngraph::helpers::ConversionTypes convType, const ngraph::PartialShape& shape, const ngraph::element::Type& iType,
-                  const ngraph::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(CreateBlob(iType, iValues, iSize)),
-          refData(CreateBlob(oType, oValues, oSize)) {}
+    ConvertParams(ngraph::helpers::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;
-    ngraph::PartialShape pshape;
-    ngraph::element::Type inType;
-    ngraph::element::Type outType;
+    ov::PartialShape pshape;
+    ov::element::Type inType;
+    ov::element::Type outType;
     ov::runtime::Tensor inputData;
     ov::runtime::Tensor refData;
 };
@@ -55,12 +51,12 @@ public:
     }
 
 private:
-    static std::shared_ptr<ngraph::Function> CreateFunction(const ngraph::PartialShape& input_shape, const ngraph::element::Type& input_type,
-                                                            const ngraph::element::Type& expected_output_type,
-                                                            const ngraph::helpers::ConversionTypes& conversion_type) {
-        const auto in = std::make_shared<ngraph::op::Parameter>(input_type, input_shape);
+    static std::shared_ptr<ov::Function> 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 auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto convert = ngraph::builder::makeConversion(in, expected_output_type, conversion_type);
-        return std::make_shared<ngraph::Function>(ngraph::NodeVector {convert}, ngraph::ParameterVector {in});
+        return std::make_shared<ov::Function>(ov::NodeVector {convert}, ov::ParameterVector {in});
     }
 };
 } // namespace ConversionOpsRefTestDefinitions
diff --git a/docs/template_plugin/tests/functional/op_reference/convert.cpp b/docs/template_plugin/tests/functional/op_reference/convert.cpp
index 68834b3a576..c90105a297c 100644
--- a/docs/template_plugin/tests/functional/op_reference/convert.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/convert.cpp
@@ -3,17 +3,12 @@
 //
 
 #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 <tuple>
 
+#include "openvino/op/convert.hpp"
 #include "conversion.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using ConversionTypes = ngraph::helpers::ConversionTypes;
 
 namespace reference_tests {
@@ -24,387 +19,387 @@ INSTANTIATE_TEST_SUITE_P(
     smoke_Conversion_With_Hardcoded_Refs, ReferenceConversionLayerTest,
     ::testing::Values(
         // destination boolean
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {2, 3}, ngraph::element::u8, ngraph::element::boolean,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {2, 3}, ov::element::u8, ov::element::boolean,
                       std::vector<uint8_t> {0, 12, 23, 0, std::numeric_limits<uint8_t>::lowest(), std::numeric_limits<uint8_t>::max()},
                       std::vector<char> {0, 1, 1, 0, 0, 1}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {2, 3}, ngraph::element::i32, ngraph::element::boolean,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {2, 3}, ov::element::i32, ov::element::boolean,
                       std::vector<int32_t> {0, -12, 23, 0, std::numeric_limits<int32_t>::lowest(), std::numeric_limits<int32_t>::max()},
                       std::vector<char> {0, 1, 1, 0, 1, 1}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {3, 3}, ngraph::element::f32, ngraph::element::boolean,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {3, 3}, ov::element::f32, ov::element::boolean,
                       std::vector<float> {0.f, 1.5745f, 0.12352f, 0.f, std::numeric_limits<float>::lowest(), std::numeric_limits<float>::max(),
                                           std::numeric_limits<float>::min(), std::numeric_limits<float>::infinity(), -std::numeric_limits<float>::infinity()},
                       std::vector<char> {0, 1, 1, 0, 1, 1, 1, 1, 1}),
         // destination bf16
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {1, 1, 3, 5}, ngraph::element::f32, ngraph::element::bf16,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {1, 1, 3, 5}, ov::element::f32, ov::element::bf16,
                       std::vector<float> {0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f},
                       std::vector<bfloat16> {0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {11}, ngraph::element::u8, ngraph::element::bf16,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {11}, ov::element::u8, ov::element::bf16,
                       std::vector<uint8_t> {0, 10, 15, 20, 43, 56, 78, 99, 102, 130, 142},
                       std::vector<bfloat16> {0, 10, 15, 20, 43, 56, 78, 99, 102, 130, 142}),
 
         // destination f16
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {1, 1, 3, 5}, ngraph::element::f32, ngraph::element::f16,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {1, 1, 3, 5}, ov::element::f32, ov::element::f16,
                       std::vector<float> {0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f},
                       std::vector<float16> {0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {11}, ngraph::element::u8, ngraph::element::f16,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {11}, ov::element::u8, ov::element::f16,
                       std::vector<uint8_t> {0, 10, 15, 20, 43, 56, 78, 99, 102, 130, 142}, std::vector<float16> {0, 10, 15, 20, 43, 56, 78, 99, 102, 130, 142}),
 
         // destination f32
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {2, 2}, ngraph::element::u1, ngraph::element::f32, std::vector<uint8_t> {0xA0},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {2, 2}, ov::element::u1, ov::element::f32, std::vector<uint8_t> {0xA0},
                       std::vector<float> {1.0f, 0.0f, 1.0f, 0.0f}, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {2, 2}, ngraph::element::u4, ngraph::element::f32, std::vector<uint8_t> {0xFB, 0x0A},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {2, 2}, ov::element::u4, ov::element::f32, std::vector<uint8_t> {0xFB, 0x0A},
                       std::vector<float> {15.0f, 11.0f, 0.0f, 10.0f}, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {2, 2}, ngraph::element::u8, ngraph::element::f32, std::vector<uint8_t> {255, 128, 32, 0},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {2, 2}, ov::element::u8, ov::element::f32, std::vector<uint8_t> {255, 128, 32, 0},
                       std::vector<float> {255.0f, 128.0f, 32.0f, 0.0f}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {2, 2}, ngraph::element::u16, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {2, 2}, ov::element::u16, ov::element::f32,
                       std::vector<uint16_t> {64000, 32000, 128, 0}, std::vector<float> {64000.0f, 32000.0f, 128.0f, 0.0f}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {2, 2}, ngraph::element::u32, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {2, 2}, ov::element::u32, ov::element::f32,
                       std::vector<uint32_t> {4000000, 2000000, 128, 0}, std::vector<float> {4000000.0f, 2000000.0f, 128.0f, 0.0f}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {2, 2}, ngraph::element::u64, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {2, 2}, ov::element::u64, ov::element::f32,
                       std::vector<uint64_t> {4000000, 2000000, 128, 0}, std::vector<float> {4000000.0f, 2000000.0f, 128.0f, 0.0f}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {2, 2}, ngraph::element::i4, ngraph::element::f32, std::vector<uint8_t> {0xFE, 0xF2},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {2, 2}, ov::element::i4, ov::element::f32, std::vector<uint8_t> {0xFE, 0xF2},
                       std::vector<float> {-1.0f, -2.0f, -1.0f, 2.0f}, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {2, 2}, ngraph::element::i8, ngraph::element::f32, std::vector<int8_t> {-127, -0, 0, 127},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {2, 2}, ov::element::i8, ov::element::f32, std::vector<int8_t> {-127, -0, 0, 127},
                       std::vector<float> {-127.0f, -0.0f, 0.0f, 127.0f}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {2, 2}, ngraph::element::i16, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {2, 2}, ov::element::i16, ov::element::f32,
                       std::vector<int16_t> {-32000, -0, 0, 32000}, std::vector<float> {-32000.0f, -0.0f, 0.0f, 32000.0f}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {2, 2}, ngraph::element::i32, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {2, 2}, ov::element::i32, ov::element::f32,
                       std::vector<int32_t> {-64000, -0, 0, 64000}, std::vector<float> {-64000.0f, -0.0f, 0.0f, 64000.0f}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {2, 2}, ngraph::element::i64, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {2, 2}, ov::element::i64, ov::element::f32,
                       std::vector<int64_t> {-64000, -0, 0, 64000}, std::vector<float> {-64000.0f, -0.0f, 0.0f, 64000.0f}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {1, 1, 3, 5}, ngraph::element::bf16, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {1, 1, 3, 5}, ov::element::bf16, ov::element::f32,
                       std::vector<bfloat16> {0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f},
                       std::vector<float> {0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {1, 1, 3, 5}, ngraph::element::f16, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {1, 1, 3, 5}, ov::element::f16, ov::element::f32,
                       std::vector<float16> {0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f},
                       std::vector<float> {0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {1, 1, 3, 5}, ngraph::element::f32, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {1, 1, 3, 5}, ov::element::f32, ov::element::f32,
                       std::vector<float> {0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f},
                       std::vector<float> {0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f}),
 
         // destination i4
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u1, ngraph::element::i4, std::vector<uint8_t> {0xA0},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u1, ov::element::i4, std::vector<uint8_t> {0xA0},
                       std::vector<uint8_t> {0x10, 0x10}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u4, ngraph::element::i4, std::vector<uint8_t> {0x12, 0x03},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u4, ov::element::i4, std::vector<uint8_t> {0x12, 0x03},
                       std::vector<uint8_t> {0x12, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u8, ngraph::element::i4, std::vector<uint8_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u8, ov::element::i4, std::vector<uint8_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {0x12, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u16, ngraph::element::i4, std::vector<uint16_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u16, ov::element::i4, std::vector<uint16_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {0x12, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u32, ngraph::element::i4, std::vector<uint32_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u32, ov::element::i4, std::vector<uint32_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {0x12, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u64, ngraph::element::i4, std::vector<uint64_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u64, ov::element::i4, std::vector<uint64_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {0x12, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i4, ngraph::element::i4, std::vector<uint8_t> {0xFE, 0x03},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i4, ov::element::i4, std::vector<uint8_t> {0xFE, 0x03},
                       std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i8, ngraph::element::i4, std::vector<int8_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i8, ov::element::i4, std::vector<int8_t> {-1, -2, 2, 3},
                       std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i16, ngraph::element::i4, std::vector<int16_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i16, ov::element::i4, std::vector<int16_t> {-1, -2, 2, 3},
                       std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i32, ngraph::element::i4, std::vector<int32_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i32, ov::element::i4, std::vector<int32_t> {-1, -2, 2, 3},
                       std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i64, ngraph::element::i4, std::vector<int64_t> {-1, -2, 2, 3},
+        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, ngraph::PartialShape {4}, ngraph::element::f16, ngraph::element::i4,
+        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),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::bf16, ngraph::element::i4,
+        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),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::f32, ngraph::element::i4, std::vector<float> {-1, -2, 2, 3},
+        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
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::u1, ngraph::element::i8, std::vector<uint8_t> {0x81},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::u1, ov::element::i8, std::vector<uint8_t> {0x81},
                       std::vector<int8_t> {1, 0, 0, 0, 0, 0, 0, 1}, 8),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u4, ngraph::element::i8, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u4, ov::element::i8, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<int8_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u8, ngraph::element::i8, std::vector<uint8_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u8, ov::element::i8, std::vector<uint8_t> {1, 2, 0, 3},
                       std::vector<int8_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u16, ngraph::element::i8, std::vector<uint16_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u16, ov::element::i8, std::vector<uint16_t> {1, 2, 0, 3},
                       std::vector<int8_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u32, ngraph::element::i8, std::vector<uint32_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u32, ov::element::i8, std::vector<uint32_t> {1, 2, 0, 3},
                       std::vector<int8_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u64, ngraph::element::i8, std::vector<uint64_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u64, ov::element::i8, std::vector<uint64_t> {1, 2, 0, 3},
                       std::vector<int8_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i4, ngraph::element::i8, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i4, ov::element::i8, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<int8_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i8, ngraph::element::i8, std::vector<int8_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i8, ov::element::i8, std::vector<int8_t> {-1, -2, 2, 3},
                       std::vector<int8_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i16, ngraph::element::i8, std::vector<int16_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i16, ov::element::i8, std::vector<int16_t> {-1, -2, 2, 3},
                       std::vector<int8_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i32, ngraph::element::i8, std::vector<int32_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i32, ov::element::i8, std::vector<int32_t> {-1, -2, 2, 3},
                       std::vector<int8_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i64, ngraph::element::i8, std::vector<int64_t> {-1, -2, 2, 3},
+        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, ngraph::PartialShape {4}, ngraph::element::f16, ngraph::element::i8,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::bf16, ngraph::element::i8,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::f32, ngraph::element::i8, std::vector<float> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, 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
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::u1, ngraph::element::i16, std::vector<uint8_t> {0x81},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::u1, ov::element::i16, std::vector<uint8_t> {0x81},
                       std::vector<int16_t> {1, 0, 0, 0, 0, 0, 0, 1}, 8),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u4, ngraph::element::i16, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u4, ov::element::i16, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<int16_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u8, ngraph::element::i16, std::vector<uint8_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u8, ov::element::i16, std::vector<uint8_t> {1, 2, 0, 3},
                       std::vector<int16_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u16, ngraph::element::i16, std::vector<uint16_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u16, ov::element::i16, std::vector<uint16_t> {1, 2, 0, 3},
                       std::vector<int16_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u32, ngraph::element::i16, std::vector<uint32_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u32, ov::element::i16, std::vector<uint32_t> {1, 2, 0, 3},
                       std::vector<int16_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u64, ngraph::element::i16, std::vector<uint64_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u64, ov::element::i16, std::vector<uint64_t> {1, 2, 0, 3},
                       std::vector<int16_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i4, ngraph::element::i16, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i4, ov::element::i16, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<int16_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i8, ngraph::element::i16, std::vector<int8_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i8, ov::element::i16, std::vector<int8_t> {-1, -2, 2, 3},
                       std::vector<int16_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i16, ngraph::element::i16, std::vector<int16_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i16, ov::element::i16, std::vector<int16_t> {-1, -2, 2, 3},
                       std::vector<int16_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i32, ngraph::element::i16, std::vector<int32_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i32, ov::element::i16, std::vector<int32_t> {-1, -2, 2, 3},
                       std::vector<int16_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i64, ngraph::element::i16, std::vector<int64_t> {-1, -2, 2, 3},
+        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, ngraph::PartialShape {4}, ngraph::element::f16, ngraph::element::i16,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::bf16, ngraph::element::i16,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::f32, ngraph::element::i16, std::vector<float> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, 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
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::u1, ngraph::element::i32, std::vector<uint8_t> {0x81},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::u1, ov::element::i32, std::vector<uint8_t> {0x81},
                       std::vector<int32_t> {1, 0, 0, 0, 0, 0, 0, 1}, 8),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u4, ngraph::element::i32, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u4, ov::element::i32, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<int32_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u8, ngraph::element::i32, std::vector<uint8_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u8, ov::element::i32, std::vector<uint8_t> {1, 2, 0, 3},
                       std::vector<int32_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u16, ngraph::element::i32, std::vector<uint16_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u16, ov::element::i32, std::vector<uint16_t> {1, 2, 0, 3},
                       std::vector<int32_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u32, ngraph::element::i32, std::vector<uint32_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u32, ov::element::i32, std::vector<uint32_t> {1, 2, 0, 3},
                       std::vector<int32_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u64, ngraph::element::i32, std::vector<uint64_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u64, ov::element::i32, std::vector<uint64_t> {1, 2, 0, 3},
                       std::vector<int32_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i4, ngraph::element::i32, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i4, ov::element::i32, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<int32_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i8, ngraph::element::i32, std::vector<int8_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i8, ov::element::i32, std::vector<int8_t> {-1, -2, 2, 3},
                       std::vector<int32_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i16, ngraph::element::i32, std::vector<int16_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i16, ov::element::i32, std::vector<int16_t> {-1, -2, 2, 3},
                       std::vector<int32_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i32, ngraph::element::i32, std::vector<int32_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i32, ov::element::i32, std::vector<int32_t> {-1, -2, 2, 3},
                       std::vector<int32_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i64, ngraph::element::i32, std::vector<int64_t> {-1, -2, 2, 3},
+        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, ngraph::PartialShape {4}, ngraph::element::f16, ngraph::element::i32,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::bf16, ngraph::element::i32,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::f32, ngraph::element::i32, std::vector<float> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, 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
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::u1, ngraph::element::i64, std::vector<uint8_t> {0x81},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::u1, ov::element::i64, std::vector<uint8_t> {0x81},
                       std::vector<int64_t> {1, 0, 0, 0, 0, 0, 0, 1}, 8),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u4, ngraph::element::i64, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u4, ov::element::i64, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<int64_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u8, ngraph::element::i64, std::vector<uint8_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u8, ov::element::i64, std::vector<uint8_t> {1, 2, 0, 3},
                       std::vector<int64_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u16, ngraph::element::i64, std::vector<uint16_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u16, ov::element::i64, std::vector<uint16_t> {1, 2, 0, 3},
                       std::vector<int64_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u32, ngraph::element::i64, std::vector<uint32_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u32, ov::element::i64, std::vector<uint32_t> {1, 2, 0, 3},
                       std::vector<int64_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u64, ngraph::element::i64, std::vector<uint64_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u64, ov::element::i64, std::vector<uint64_t> {1, 2, 0, 3},
                       std::vector<int64_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i4, ngraph::element::i64, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i4, ov::element::i64, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<int64_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i8, ngraph::element::i64, std::vector<int8_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i8, ov::element::i64, std::vector<int8_t> {-1, -2, 2, 3},
                       std::vector<int64_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i16, ngraph::element::i64, std::vector<int16_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i16, ov::element::i64, std::vector<int16_t> {-1, -2, 2, 3},
                       std::vector<int64_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i32, ngraph::element::i64, std::vector<int32_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i32, ov::element::i64, std::vector<int32_t> {-1, -2, 2, 3},
                       std::vector<int64_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i64, ngraph::element::i64, std::vector<int64_t> {-1, -2, 2, 3},
+        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, ngraph::PartialShape {4}, ngraph::element::f16, ngraph::element::i64,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::bf16, ngraph::element::i64,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::f32, ngraph::element::i64, std::vector<float> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::i64, std::vector<float> {-1, -2, 2, 3},
                       std::vector<int64_t> {-1, -2, 2, 3}),
 
         // destination u1
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::u1, ngraph::element::u1, std::vector<uint8_t> {0xA0},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::u1, ov::element::u1, std::vector<uint8_t> {0xA0},
                       std::vector<uint8_t> {0xA0}, 8, 8),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::u4, ngraph::element::u1,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::u4, ov::element::u1,
                       std::vector<uint8_t> {0x10, 0x01, 0x00, 0x00}, std::vector<uint8_t> {0x90}, 8, 8),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::u8, ngraph::element::u1,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::u8, ov::element::u1,
                       std::vector<uint8_t> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::u16, ngraph::element::u1,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::u16, ov::element::u1,
                       std::vector<uint16_t> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::u32, ngraph::element::u1,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::u32, ov::element::u1,
                       std::vector<uint32_t> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::u64, ngraph::element::u1,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::u64, ov::element::u1,
                       std::vector<uint64_t> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::i4, ngraph::element::u1,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::i4, ov::element::u1,
                       std::vector<uint8_t> {0x10, 0x01, 0x00, 0x00}, std::vector<uint8_t> {0x90}, 8, 8),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::i8, ngraph::element::u1,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::i8, ov::element::u1,
                       std::vector<int8_t> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::i16, ngraph::element::u1,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::i16, ov::element::u1,
                       std::vector<int16_t> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::i32, ngraph::element::u1,
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::i32, ov::element::u1,
                       std::vector<int32_t> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::i64, ngraph::element::u1,
+        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, ngraph::PartialShape {8}, ngraph::element::f16, ngraph::element::u1,
+        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),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::bf16, ngraph::element::u1,
+        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),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::f32, ngraph::element::u1,
+        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),
 
         // destination u4
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u1, ngraph::element::u4, std::vector<uint8_t> {0xA0},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u1, ov::element::u4, std::vector<uint8_t> {0xA0},
                       std::vector<uint8_t> {0x10, 0x10}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u4, ngraph::element::u4, std::vector<uint8_t> {0x12, 0x03},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u4, ov::element::u4, std::vector<uint8_t> {0x12, 0x03},
                       std::vector<uint8_t> {0x12, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u8, ngraph::element::u4, std::vector<uint8_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u8, ov::element::u4, std::vector<uint8_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {0x12, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u16, ngraph::element::u4, std::vector<uint16_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u16, ov::element::u4, std::vector<uint16_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {0x12, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u32, ngraph::element::u4, std::vector<uint32_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u32, ov::element::u4, std::vector<uint32_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {0x12, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u64, ngraph::element::u4, std::vector<uint64_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u64, ov::element::u4, std::vector<uint64_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {0x12, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i4, ngraph::element::u4, std::vector<uint8_t> {0xFE, 0x03},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i4, ov::element::u4, std::vector<uint8_t> {0xFE, 0x03},
                       std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i8, ngraph::element::u4, std::vector<int8_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i8, ov::element::u4, std::vector<int8_t> {-1, -2, 2, 3},
                       std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i16, ngraph::element::u4, std::vector<int16_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i16, ov::element::u4, std::vector<int16_t> {-1, -2, 2, 3},
                       std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i32, ngraph::element::u4, std::vector<int32_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i32, ov::element::u4, std::vector<int32_t> {-1, -2, 2, 3},
                       std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i64, ngraph::element::u4, std::vector<int64_t> {-1, -2, 2, 3},
+        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, ngraph::PartialShape {4}, ngraph::element::f16, ngraph::element::u4,
+        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),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::bf16, ngraph::element::u4,
+        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),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::f32, ngraph::element::u4, std::vector<float> {-1, -2, 2, 3},
+        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),
 
         // destination u8
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::u1, ngraph::element::u8, std::vector<uint8_t> {0x81},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::u1, ov::element::u8, std::vector<uint8_t> {0x81},
                       std::vector<uint8_t> {1, 0, 0, 0, 0, 0, 0, 1}, 8),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u4, ngraph::element::u8, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u4, ov::element::u8, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<uint8_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u8, ngraph::element::u8, std::vector<uint8_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u8, ov::element::u8, std::vector<uint8_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u16, ngraph::element::u8, std::vector<uint16_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u16, ov::element::u8, std::vector<uint16_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u32, ngraph::element::u8, std::vector<uint32_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u32, ov::element::u8, std::vector<uint32_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u64, ngraph::element::u8, std::vector<uint64_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u64, ov::element::u8, std::vector<uint64_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i4, ngraph::element::u8, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i4, ov::element::u8, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<uint8_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i8, ngraph::element::u8, std::vector<int8_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i8, ov::element::u8, std::vector<int8_t> {1, 2, 2, 3},
                       std::vector<uint8_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i16, ngraph::element::u8, std::vector<int16_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i16, ov::element::u8, std::vector<int16_t> {1, 2, 2, 3},
                       std::vector<uint8_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i32, ngraph::element::u8, std::vector<int32_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i32, ov::element::u8, std::vector<int32_t> {1, 2, 2, 3},
                       std::vector<uint8_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i64, ngraph::element::u8, std::vector<int64_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, ngraph::PartialShape {4}, ngraph::element::f16, ngraph::element::u8, std::vector<ngraph::float16> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, 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}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::bf16, ngraph::element::u8,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::f32, ngraph::element::u8, std::vector<float> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::u8, std::vector<float> {1, 2, 2, 3},
                       std::vector<uint8_t> {1, 2, 2, 3}),
 
         // destination u16
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::u1, ngraph::element::u16, std::vector<uint8_t> {0x81},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::u1, ov::element::u16, std::vector<uint8_t> {0x81},
                       std::vector<uint16_t> {1, 0, 0, 0, 0, 0, 0, 1}, 8),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u4, ngraph::element::u16, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u4, ov::element::u16, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<uint16_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u8, ngraph::element::u16, std::vector<uint8_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u8, ov::element::u16, std::vector<uint8_t> {1, 2, 0, 3},
                       std::vector<uint16_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u16, ngraph::element::u16, std::vector<uint16_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u16, ov::element::u16, std::vector<uint16_t> {1, 2, 0, 3},
                       std::vector<uint16_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u32, ngraph::element::u16, std::vector<uint32_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u32, ov::element::u16, std::vector<uint32_t> {1, 2, 0, 3},
                       std::vector<uint16_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u64, ngraph::element::u16, std::vector<uint64_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u64, ov::element::u16, std::vector<uint64_t> {1, 2, 0, 3},
                       std::vector<uint16_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i4, ngraph::element::u16, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i4, ov::element::u16, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<uint16_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i8, ngraph::element::u16, std::vector<int8_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i8, ov::element::u16, std::vector<int8_t> {1, 2, 2, 3},
                       std::vector<uint16_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i16, ngraph::element::u16, std::vector<int16_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i16, ov::element::u16, std::vector<int16_t> {1, 2, 2, 3},
                       std::vector<uint16_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i32, ngraph::element::u16, std::vector<int32_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i32, ov::element::u16, std::vector<int32_t> {1, 2, 2, 3},
                       std::vector<uint16_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i64, ngraph::element::u16, std::vector<int64_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, ngraph::PartialShape {4}, ngraph::element::f16, ngraph::element::u16, std::vector<ngraph::float16> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, 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}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::bf16, ngraph::element::u16,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::f32, ngraph::element::u16, std::vector<float> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::f32, ov::element::u16, std::vector<float> {1, 2, 2, 3},
                       std::vector<uint16_t> {1, 2, 2, 3}),
 
         // destination u32
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::u1, ngraph::element::u32, std::vector<uint8_t> {0x81},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::u1, ov::element::u32, std::vector<uint8_t> {0x81},
                       std::vector<uint32_t> {1, 0, 0, 0, 0, 0, 0, 1}, 8),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u4, ngraph::element::u32, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u4, ov::element::u32, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<uint32_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u8, ngraph::element::u32, std::vector<uint8_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u8, ov::element::u32, std::vector<uint8_t> {1, 2, 0, 3},
                       std::vector<uint32_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u16, ngraph::element::u32, std::vector<uint16_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u16, ov::element::u32, std::vector<uint16_t> {1, 2, 0, 3},
                       std::vector<uint32_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u32, ngraph::element::u32, std::vector<uint32_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u32, ov::element::u32, std::vector<uint32_t> {1, 2, 0, 3},
                       std::vector<uint32_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u64, ngraph::element::u32, std::vector<uint64_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u64, ov::element::u32, std::vector<uint64_t> {1, 2, 0, 3},
                       std::vector<uint32_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i4, ngraph::element::u32, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i4, ov::element::u32, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<uint32_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i8, ngraph::element::u32, std::vector<int8_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i8, ov::element::u32, std::vector<int8_t> {1, 2, 2, 3},
                       std::vector<uint32_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i16, ngraph::element::u32, std::vector<int16_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i16, ov::element::u32, std::vector<int16_t> {1, 2, 2, 3},
                       std::vector<uint32_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i32, ngraph::element::u32, std::vector<int32_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i32, ov::element::u32, std::vector<int32_t> {1, 2, 2, 3},
                       std::vector<uint32_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i64, ngraph::element::u32, std::vector<int64_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, ngraph::PartialShape {4}, ngraph::element::f16, ngraph::element::u32, std::vector<ngraph::float16> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, 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}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::bf16, ngraph::element::u32,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::f32, ngraph::element::u32, std::vector<float> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, 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
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {8}, ngraph::element::u1, ngraph::element::u64, std::vector<uint8_t> {0x81},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {8}, ov::element::u1, ov::element::u64, std::vector<uint8_t> {0x81},
                       std::vector<uint64_t> {1, 0, 0, 0, 0, 0, 0, 1}, 8),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u4, ngraph::element::u64, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u4, ov::element::u64, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<uint64_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u8, ngraph::element::u64, std::vector<uint8_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u8, ov::element::u64, std::vector<uint8_t> {1, 2, 0, 3},
                       std::vector<uint64_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u16, ngraph::element::u64, std::vector<uint16_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u16, ov::element::u64, std::vector<uint16_t> {1, 2, 0, 3},
                       std::vector<uint64_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u32, ngraph::element::u64, std::vector<uint32_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u32, ov::element::u64, std::vector<uint32_t> {1, 2, 0, 3},
                       std::vector<uint64_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::u64, ngraph::element::u64, std::vector<uint64_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::u64, ov::element::u64, std::vector<uint64_t> {1, 2, 0, 3},
                       std::vector<uint64_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i4, ngraph::element::u64, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i4, ov::element::u64, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<uint64_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i8, ngraph::element::u64, std::vector<int8_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i8, ov::element::u64, std::vector<int8_t> {1, 2, 2, 3},
                       std::vector<uint64_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i16, ngraph::element::u64, std::vector<int16_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i16, ov::element::u64, std::vector<int16_t> {1, 2, 2, 3},
                       std::vector<uint64_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i32, ngraph::element::u64, std::vector<int32_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, ov::PartialShape {4}, ov::element::i32, ov::element::u64, std::vector<int32_t> {1, 2, 2, 3},
                       std::vector<uint64_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::i64, ngraph::element::u64, std::vector<int64_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, ngraph::PartialShape {4}, ngraph::element::f16, ngraph::element::u64, std::vector<ngraph::float16> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT, 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}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::bf16, ngraph::element::u64,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT, ngraph::PartialShape {4}, ngraph::element::f32, ngraph::element::u64, std::vector<float> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT, 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);
 } // namespace
diff --git a/docs/template_plugin/tests/functional/op_reference/convert_like.cpp b/docs/template_plugin/tests/functional/op_reference/convert_like.cpp
index cd745c4040a..8010704bb83 100644
--- a/docs/template_plugin/tests/functional/op_reference/convert_like.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/convert_like.cpp
@@ -4,16 +4,10 @@
 
 #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 "openvino/op/convert_like.hpp"
 #include "conversion.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using ConversionTypes = ngraph::helpers::ConversionTypes;
 
 namespace reference_tests {
@@ -24,388 +18,388 @@ INSTANTIATE_TEST_SUITE_P(
     smoke_Conversion_With_Hardcoded_Refs, ReferenceConversionLayerTest,
     ::testing::Values(
         // destination boolean
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {2, 3}, ngraph::element::u8, ngraph::element::boolean,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {2, 3}, ov::element::u8, ov::element::boolean,
                       std::vector<uint8_t> {0, 12, 23, 0, std::numeric_limits<uint8_t>::lowest(), std::numeric_limits<uint8_t>::max()},
                       std::vector<char> {0, 1, 1, 0, 0, 1}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {2, 3}, ngraph::element::i32, ngraph::element::boolean,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {2, 3}, ov::element::i32, ov::element::boolean,
                       std::vector<int32_t> {0, -12, 23, 0, std::numeric_limits<int32_t>::lowest(), std::numeric_limits<int32_t>::max()},
                       std::vector<char> {0, 1, 1, 0, 1, 1}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {3, 3}, ngraph::element::f32, ngraph::element::boolean,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {3, 3}, ov::element::f32, ov::element::boolean,
                       std::vector<float> {0.f, 1.5745f, 0.12352f, 0.f, std::numeric_limits<float>::lowest(), std::numeric_limits<float>::max(),
                                           std::numeric_limits<float>::min(), std::numeric_limits<float>::infinity(), -std::numeric_limits<float>::infinity()},
                       std::vector<char> {0, 1, 1, 0, 1, 1, 1, 1, 1}),
         // destination bf16
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {1, 1, 3, 5}, ngraph::element::f32, ngraph::element::bf16,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {1, 1, 3, 5}, ov::element::f32, ov::element::bf16,
                       std::vector<float> {0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f},
                       std::vector<bfloat16> {0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {11}, ngraph::element::u8, ngraph::element::bf16,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {11}, ov::element::u8, ov::element::bf16,
                       std::vector<uint8_t> {0, 10, 15, 20, 43, 56, 78, 99, 102, 130, 142},
                       std::vector<bfloat16> {0, 10, 15, 20, 43, 56, 78, 99, 102, 130, 142}),
 
         // destination f16
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {1, 1, 3, 5}, ngraph::element::f32, ngraph::element::f16,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {1, 1, 3, 5}, ov::element::f32, ov::element::f16,
                       std::vector<float> {0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f},
                       std::vector<float16> {0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {11}, ngraph::element::u8, ngraph::element::f16,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {11}, ov::element::u8, ov::element::f16,
                       std::vector<uint8_t> {0, 10, 15, 20, 43, 56, 78, 99, 102, 130, 142},
                       std::vector<float16> {0, 10, 15, 20, 43, 56, 78, 99, 102, 130, 142}),
 
         // destination f32
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {2, 2}, ngraph::element::u1, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {2, 2}, ov::element::u1, ov::element::f32,
                       std::vector<uint8_t> {0xA0}, std::vector<float> {1.0f, 0.0f, 1.0f, 0.0f}, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {2, 2}, ngraph::element::u4, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {2, 2}, ov::element::u4, ov::element::f32,
                       std::vector<uint8_t> {0xFB, 0x0A}, std::vector<float> {15.0f, 11.0f, 0.0f, 10.0f}, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {2, 2}, ngraph::element::u8, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {2, 2}, ov::element::u8, ov::element::f32,
                       std::vector<uint8_t> {255, 128, 32, 0}, std::vector<float> {255.0f, 128.0f, 32.0f, 0.0f}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {2, 2}, ngraph::element::u16, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {2, 2}, ov::element::u16, ov::element::f32,
                       std::vector<uint16_t> {64000, 32000, 128, 0}, std::vector<float> {64000.0f, 32000.0f, 128.0f, 0.0f}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {2, 2}, ngraph::element::u32, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {2, 2}, ov::element::u32, ov::element::f32,
                       std::vector<uint32_t> {4000000, 2000000, 128, 0}, std::vector<float> {4000000.0f, 2000000.0f, 128.0f, 0.0f}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {2, 2}, ngraph::element::u64, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {2, 2}, ov::element::u64, ov::element::f32,
                       std::vector<uint64_t> {4000000, 2000000, 128, 0}, std::vector<float> {4000000.0f, 2000000.0f, 128.0f, 0.0f}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {2, 2}, ngraph::element::i4, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {2, 2}, ov::element::i4, ov::element::f32,
                       std::vector<uint8_t> {0xFE, 0xF2}, std::vector<float> {-1.0f, -2.0f, -1.0f, 2.0f}, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {2, 2}, ngraph::element::i8, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {2, 2}, ov::element::i8, ov::element::f32,
                       std::vector<int8_t> {-127, -0, 0, 127}, std::vector<float> {-127.0f, -0.0f, 0.0f, 127.0f}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {2, 2}, ngraph::element::i16, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {2, 2}, ov::element::i16, ov::element::f32,
                       std::vector<int16_t> {-32000, -0, 0, 32000}, std::vector<float> {-32000.0f, -0.0f, 0.0f, 32000.0f}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {2, 2}, ngraph::element::i32, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {2, 2}, ov::element::i32, ov::element::f32,
                       std::vector<int32_t> {-64000, -0, 0, 64000}, std::vector<float> {-64000.0f, -0.0f, 0.0f, 64000.0f}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {2, 2}, ngraph::element::i64, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {2, 2}, ov::element::i64, ov::element::f32,
                       std::vector<int64_t> {-64000, -0, 0, 64000}, std::vector<float> {-64000.0f, -0.0f, 0.0f, 64000.0f}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {1, 1, 3, 5}, ngraph::element::bf16, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {1, 1, 3, 5}, ov::element::bf16, ov::element::f32,
                       std::vector<bfloat16> {0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f},
                       std::vector<float> {0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {1, 1, 3, 5}, ngraph::element::f16, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {1, 1, 3, 5}, ov::element::f16, ov::element::f32,
                       std::vector<float16> {0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f},
                       std::vector<float> {0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {1, 1, 3, 5}, ngraph::element::f32, ngraph::element::f32,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {1, 1, 3, 5}, ov::element::f32, ov::element::f32,
                       std::vector<float> {0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f},
                       std::vector<float> {0.5f, 1.5f, 0.5f, 2.5f, 1.5f, 0.5f, 3.5f, 2.5f, 0.5f, 0.5f, 2.5f, 0.5f, 0.5f, 0.5f, 1.5f}),
 
         // destination i4
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u1, ngraph::element::i4, std::vector<uint8_t> {0xA0},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u1, ov::element::i4, std::vector<uint8_t> {0xA0},
                       std::vector<uint8_t> {0x10, 0x10}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u4, ngraph::element::i4, std::vector<uint8_t> {0x12, 0x03},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u4, ov::element::i4, std::vector<uint8_t> {0x12, 0x03},
                       std::vector<uint8_t> {0x12, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u8, ngraph::element::i4, std::vector<uint8_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u8, ov::element::i4, std::vector<uint8_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {0x12, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u16, ngraph::element::i4, std::vector<uint16_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u16, ov::element::i4, std::vector<uint16_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {0x12, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u32, ngraph::element::i4, std::vector<uint32_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u32, ov::element::i4, std::vector<uint32_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {0x12, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u64, ngraph::element::i4, std::vector<uint64_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u64, ov::element::i4, std::vector<uint64_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {0x12, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i4, ngraph::element::i4, std::vector<uint8_t> {0xFE, 0x03},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i4, ov::element::i4, std::vector<uint8_t> {0xFE, 0x03},
                       std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i8, ngraph::element::i4, std::vector<int8_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i8, ov::element::i4, std::vector<int8_t> {-1, -2, 2, 3},
                       std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i16, ngraph::element::i4, std::vector<int16_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i16, ov::element::i4, std::vector<int16_t> {-1, -2, 2, 3},
                       std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i32, ngraph::element::i4, std::vector<int32_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i32, ov::element::i4, std::vector<int32_t> {-1, -2, 2, 3},
                       std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i64, ngraph::element::i4, std::vector<int64_t> {-1, -2, 2, 3},
+        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, ngraph::PartialShape {4}, ngraph::element::f16, ngraph::element::i4,
+        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),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::bf16, ngraph::element::i4,
+        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),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::f32, ngraph::element::i4, std::vector<float> {-1, -2, 2, 3},
+        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
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::u1, ngraph::element::i8, std::vector<uint8_t> {0x81},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::u1, ov::element::i8, std::vector<uint8_t> {0x81},
                       std::vector<int8_t> {1, 0, 0, 0, 0, 0, 0, 1}, 8),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u4, ngraph::element::i8, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u4, ov::element::i8, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<int8_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u8, ngraph::element::i8, std::vector<uint8_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u8, ov::element::i8, std::vector<uint8_t> {1, 2, 0, 3},
                       std::vector<int8_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u16, ngraph::element::i8, std::vector<uint16_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u16, ov::element::i8, std::vector<uint16_t> {1, 2, 0, 3},
                       std::vector<int8_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u32, ngraph::element::i8, std::vector<uint32_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u32, ov::element::i8, std::vector<uint32_t> {1, 2, 0, 3},
                       std::vector<int8_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u64, ngraph::element::i8, std::vector<uint64_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u64, ov::element::i8, std::vector<uint64_t> {1, 2, 0, 3},
                       std::vector<int8_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i4, ngraph::element::i8, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i4, ov::element::i8, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<int8_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i8, ngraph::element::i8, std::vector<int8_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i8, ov::element::i8, std::vector<int8_t> {-1, -2, 2, 3},
                       std::vector<int8_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i16, ngraph::element::i8, std::vector<int16_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i16, ov::element::i8, std::vector<int16_t> {-1, -2, 2, 3},
                       std::vector<int8_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i32, ngraph::element::i8, std::vector<int32_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i32, ov::element::i8, std::vector<int32_t> {-1, -2, 2, 3},
                       std::vector<int8_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i64, ngraph::element::i8, std::vector<int64_t> {-1, -2, 2, 3},
+        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, ngraph::PartialShape {4}, ngraph::element::f16, ngraph::element::i8,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::bf16, ngraph::element::i8,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::f32, ngraph::element::i8, std::vector<float> {-1, -2, 2, 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
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::u1, ngraph::element::i16, std::vector<uint8_t> {0x81},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::u1, ov::element::i16, std::vector<uint8_t> {0x81},
                       std::vector<int16_t> {1, 0, 0, 0, 0, 0, 0, 1}, 8),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u4, ngraph::element::i16, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u4, ov::element::i16, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<int16_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u8, ngraph::element::i16, std::vector<uint8_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u8, ov::element::i16, std::vector<uint8_t> {1, 2, 0, 3},
                       std::vector<int16_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u16, ngraph::element::i16, std::vector<uint16_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u16, ov::element::i16, std::vector<uint16_t> {1, 2, 0, 3},
                       std::vector<int16_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u32, ngraph::element::i16, std::vector<uint32_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u32, ov::element::i16, std::vector<uint32_t> {1, 2, 0, 3},
                       std::vector<int16_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u64, ngraph::element::i16, std::vector<uint64_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u64, ov::element::i16, std::vector<uint64_t> {1, 2, 0, 3},
                       std::vector<int16_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i4, ngraph::element::i16, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i4, ov::element::i16, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<int16_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i8, ngraph::element::i16, std::vector<int8_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i8, ov::element::i16, std::vector<int8_t> {-1, -2, 2, 3},
                       std::vector<int16_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i16, ngraph::element::i16, std::vector<int16_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i16, ov::element::i16, std::vector<int16_t> {-1, -2, 2, 3},
                       std::vector<int16_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i32, ngraph::element::i16, std::vector<int32_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i32, ov::element::i16, std::vector<int32_t> {-1, -2, 2, 3},
                       std::vector<int16_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i64, ngraph::element::i16, std::vector<int64_t> {-1, -2, 2, 3},
+        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, ngraph::PartialShape {4}, ngraph::element::f16, ngraph::element::i16,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::bf16, ngraph::element::i16,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::f32, ngraph::element::i16, std::vector<float> {-1, -2, 2, 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
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::u1, ngraph::element::i32, std::vector<uint8_t> {0x81},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::u1, ov::element::i32, std::vector<uint8_t> {0x81},
                       std::vector<int32_t> {1, 0, 0, 0, 0, 0, 0, 1}, 8),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u4, ngraph::element::i32, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u4, ov::element::i32, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<int32_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u8, ngraph::element::i32, std::vector<uint8_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u8, ov::element::i32, std::vector<uint8_t> {1, 2, 0, 3},
                       std::vector<int32_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u16, ngraph::element::i32, std::vector<uint16_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u16, ov::element::i32, std::vector<uint16_t> {1, 2, 0, 3},
                       std::vector<int32_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u32, ngraph::element::i32, std::vector<uint32_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u32, ov::element::i32, std::vector<uint32_t> {1, 2, 0, 3},
                       std::vector<int32_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u64, ngraph::element::i32, std::vector<uint64_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u64, ov::element::i32, std::vector<uint64_t> {1, 2, 0, 3},
                       std::vector<int32_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i4, ngraph::element::i32, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i4, ov::element::i32, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<int32_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i8, ngraph::element::i32, std::vector<int8_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i8, ov::element::i32, std::vector<int8_t> {-1, -2, 2, 3},
                       std::vector<int32_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i16, ngraph::element::i32, std::vector<int16_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i16, ov::element::i32, std::vector<int16_t> {-1, -2, 2, 3},
                       std::vector<int32_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i32, ngraph::element::i32, std::vector<int32_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i32, ov::element::i32, std::vector<int32_t> {-1, -2, 2, 3},
                       std::vector<int32_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i64, ngraph::element::i32, std::vector<int64_t> {-1, -2, 2, 3},
+        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, ngraph::PartialShape {4}, ngraph::element::f16, ngraph::element::i32,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::bf16, ngraph::element::i32,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::f32, ngraph::element::i32, std::vector<float> {-1, -2, 2, 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
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::u1, ngraph::element::i64, std::vector<uint8_t> {0x81},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::u1, ov::element::i64, std::vector<uint8_t> {0x81},
                       std::vector<int64_t> {1, 0, 0, 0, 0, 0, 0, 1}, 8),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u4, ngraph::element::i64, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u4, ov::element::i64, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<int64_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u8, ngraph::element::i64, std::vector<uint8_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u8, ov::element::i64, std::vector<uint8_t> {1, 2, 0, 3},
                       std::vector<int64_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u16, ngraph::element::i64, std::vector<uint16_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u16, ov::element::i64, std::vector<uint16_t> {1, 2, 0, 3},
                       std::vector<int64_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u32, ngraph::element::i64, std::vector<uint32_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u32, ov::element::i64, std::vector<uint32_t> {1, 2, 0, 3},
                       std::vector<int64_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u64, ngraph::element::i64, std::vector<uint64_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u64, ov::element::i64, std::vector<uint64_t> {1, 2, 0, 3},
                       std::vector<int64_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i4, ngraph::element::i64, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i4, ov::element::i64, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<int64_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i8, ngraph::element::i64, std::vector<int8_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i8, ov::element::i64, std::vector<int8_t> {-1, -2, 2, 3},
                       std::vector<int64_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i16, ngraph::element::i64, std::vector<int16_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i16, ov::element::i64, std::vector<int16_t> {-1, -2, 2, 3},
                       std::vector<int64_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i32, ngraph::element::i64, std::vector<int32_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i32, ov::element::i64, std::vector<int32_t> {-1, -2, 2, 3},
                       std::vector<int64_t> {-1, -2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i64, ngraph::element::i64, std::vector<int64_t> {-1, -2, 2, 3},
+        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, ngraph::PartialShape {4}, ngraph::element::f16, ngraph::element::i64,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::bf16, ngraph::element::i64,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::f32, ngraph::element::i64, std::vector<float> {-1, -2, 2, 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}),
 
         // destination u1
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::u1, ngraph::element::u1, std::vector<uint8_t> {0xA0},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::u1, ov::element::u1, std::vector<uint8_t> {0xA0},
                       std::vector<uint8_t> {0xA0}, 8, 8),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::u4, ngraph::element::u1,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::u4, ov::element::u1,
                       std::vector<uint8_t> {0x10, 0x01, 0x00, 0x00}, std::vector<uint8_t> {0x90}, 8, 8),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::u8, ngraph::element::u1,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::u8, ov::element::u1,
                       std::vector<uint8_t> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::u16, ngraph::element::u1,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::u16, ov::element::u1,
                       std::vector<uint16_t> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::u32, ngraph::element::u1,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::u32, ov::element::u1,
                       std::vector<uint32_t> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::u64, ngraph::element::u1,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::u64, ov::element::u1,
                       std::vector<uint64_t> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::i4, ngraph::element::u1,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::i4, ov::element::u1,
                       std::vector<uint8_t> {0x10, 0x01, 0x00, 0x00}, std::vector<uint8_t> {0x90}, 8, 8),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::i8, ngraph::element::u1,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::i8, ov::element::u1,
                       std::vector<int8_t> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::i16, ngraph::element::u1,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::i16, ov::element::u1,
                       std::vector<int16_t> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::i32, ngraph::element::u1,
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::i32, ov::element::u1,
                       std::vector<int32_t> {1, 0, 1, 0, 0, 0, 0, 1}, std::vector<uint8_t> {0xA1}, 8, 8),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::i64, ngraph::element::u1,
+        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, ngraph::PartialShape {8}, ngraph::element::f16, ngraph::element::u1,
+        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),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::bf16, ngraph::element::u1,
+        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),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::f32, ngraph::element::u1,
+        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),
 
         // destination u4
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u1, ngraph::element::u4, std::vector<uint8_t> {0xA0},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u1, ov::element::u4, std::vector<uint8_t> {0xA0},
                       std::vector<uint8_t> {0x10, 0x10}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u4, ngraph::element::u4, std::vector<uint8_t> {0x12, 0x03},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u4, ov::element::u4, std::vector<uint8_t> {0x12, 0x03},
                       std::vector<uint8_t> {0x12, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u8, ngraph::element::u4, std::vector<uint8_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u8, ov::element::u4, std::vector<uint8_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {0x12, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u16, ngraph::element::u4, std::vector<uint16_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u16, ov::element::u4, std::vector<uint16_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {0x12, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u32, ngraph::element::u4, std::vector<uint32_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u32, ov::element::u4, std::vector<uint32_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {0x12, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u64, ngraph::element::u4, std::vector<uint64_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u64, ov::element::u4, std::vector<uint64_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {0x12, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i4, ngraph::element::u4, std::vector<uint8_t> {0xFE, 0x03},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i4, ov::element::u4, std::vector<uint8_t> {0xFE, 0x03},
                       std::vector<uint8_t> {0xFE, 0x03}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i8, ngraph::element::u4, std::vector<int8_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i8, ov::element::u4, std::vector<int8_t> {-1, -2, 2, 3},
                       std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i16, ngraph::element::u4, std::vector<int16_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i16, ov::element::u4, std::vector<int16_t> {-1, -2, 2, 3},
                       std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i32, ngraph::element::u4, std::vector<int32_t> {-1, -2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i32, ov::element::u4, std::vector<int32_t> {-1, -2, 2, 3},
                       std::vector<uint8_t> {0xFE, 0x23}, 4, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i64, ngraph::element::u4, std::vector<int64_t> {-1, -2, 2, 3},
+        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, ngraph::PartialShape {4}, ngraph::element::f16, ngraph::element::u4,
+        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),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::bf16, ngraph::element::u4,
+        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),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::f32, ngraph::element::u4, std::vector<float> {-1, -2, 2, 3},
+        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),
 
         // destination u8
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::u1, ngraph::element::u8, std::vector<uint8_t> {0x81},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::u1, ov::element::u8, std::vector<uint8_t> {0x81},
                       std::vector<uint8_t> {1, 0, 0, 0, 0, 0, 0, 1}, 8),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u4, ngraph::element::u8, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u4, ov::element::u8, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<uint8_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u8, ngraph::element::u8, std::vector<uint8_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u8, ov::element::u8, std::vector<uint8_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u16, ngraph::element::u8, std::vector<uint16_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u16, ov::element::u8, std::vector<uint16_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u32, ngraph::element::u8, std::vector<uint32_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u32, ov::element::u8, std::vector<uint32_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u64, ngraph::element::u8, std::vector<uint64_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u64, ov::element::u8, std::vector<uint64_t> {1, 2, 0, 3},
                       std::vector<uint8_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i4, ngraph::element::u8, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i4, ov::element::u8, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<uint8_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i8, ngraph::element::u8, std::vector<int8_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i8, ov::element::u8, std::vector<int8_t> {1, 2, 2, 3},
                       std::vector<uint8_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i16, ngraph::element::u8, std::vector<int16_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i16, ov::element::u8, std::vector<int16_t> {1, 2, 2, 3},
                       std::vector<uint8_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i32, ngraph::element::u8, std::vector<int32_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i32, ov::element::u8, std::vector<int32_t> {1, 2, 2, 3},
                       std::vector<uint8_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i64, ngraph::element::u8, std::vector<int64_t> {1, 2, 2, 3},
+        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, ngraph::PartialShape {4}, ngraph::element::f16, ngraph::element::u8,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::bf16, ngraph::element::u8,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::f32, ngraph::element::u8, std::vector<float> {1, 2, 2, 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}),
 
         // destination u16
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::u1, ngraph::element::u16, std::vector<uint8_t> {0x81},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::u1, ov::element::u16, std::vector<uint8_t> {0x81},
                       std::vector<uint16_t> {1, 0, 0, 0, 0, 0, 0, 1}, 8),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u4, ngraph::element::u16, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u4, ov::element::u16, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<uint16_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u8, ngraph::element::u16, std::vector<uint8_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u8, ov::element::u16, std::vector<uint8_t> {1, 2, 0, 3},
                       std::vector<uint16_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u16, ngraph::element::u16, std::vector<uint16_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u16, ov::element::u16, std::vector<uint16_t> {1, 2, 0, 3},
                       std::vector<uint16_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u32, ngraph::element::u16, std::vector<uint32_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u32, ov::element::u16, std::vector<uint32_t> {1, 2, 0, 3},
                       std::vector<uint16_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u64, ngraph::element::u16, std::vector<uint64_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u64, ov::element::u16, std::vector<uint64_t> {1, 2, 0, 3},
                       std::vector<uint16_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i4, ngraph::element::u16, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i4, ov::element::u16, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<uint16_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i8, ngraph::element::u16, std::vector<int8_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i8, ov::element::u16, std::vector<int8_t> {1, 2, 2, 3},
                       std::vector<uint16_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i16, ngraph::element::u16, std::vector<int16_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i16, ov::element::u16, std::vector<int16_t> {1, 2, 2, 3},
                       std::vector<uint16_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i32, ngraph::element::u16, std::vector<int32_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i32, ov::element::u16, std::vector<int32_t> {1, 2, 2, 3},
                       std::vector<uint16_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i64, ngraph::element::u16, std::vector<int64_t> {1, 2, 2, 3},
+        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, ngraph::PartialShape {4}, ngraph::element::f16, ngraph::element::u16,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::bf16, ngraph::element::u16,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::f32, ngraph::element::u16, std::vector<float> {1, 2, 2, 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}),
 
         // destination u32
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::u1, ngraph::element::u32, std::vector<uint8_t> {0x81},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::u1, ov::element::u32, std::vector<uint8_t> {0x81},
                       std::vector<uint32_t> {1, 0, 0, 0, 0, 0, 0, 1}, 8),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u4, ngraph::element::u32, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u4, ov::element::u32, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<uint32_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u8, ngraph::element::u32, std::vector<uint8_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u8, ov::element::u32, std::vector<uint8_t> {1, 2, 0, 3},
                       std::vector<uint32_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u16, ngraph::element::u32, std::vector<uint16_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u16, ov::element::u32, std::vector<uint16_t> {1, 2, 0, 3},
                       std::vector<uint32_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u32, ngraph::element::u32, std::vector<uint32_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u32, ov::element::u32, std::vector<uint32_t> {1, 2, 0, 3},
                       std::vector<uint32_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u64, ngraph::element::u32, std::vector<uint64_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u64, ov::element::u32, std::vector<uint64_t> {1, 2, 0, 3},
                       std::vector<uint32_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i4, ngraph::element::u32, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i4, ov::element::u32, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<uint32_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i8, ngraph::element::u32, std::vector<int8_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i8, ov::element::u32, std::vector<int8_t> {1, 2, 2, 3},
                       std::vector<uint32_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i16, ngraph::element::u32, std::vector<int16_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i16, ov::element::u32, std::vector<int16_t> {1, 2, 2, 3},
                       std::vector<uint32_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i32, ngraph::element::u32, std::vector<int32_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i32, ov::element::u32, std::vector<int32_t> {1, 2, 2, 3},
                       std::vector<uint32_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i64, ngraph::element::u32, std::vector<int64_t> {1, 2, 2, 3},
+        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, ngraph::PartialShape {4}, ngraph::element::f16, ngraph::element::u32,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::bf16, ngraph::element::u32,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::f32, ngraph::element::u32, std::vector<float> {1, 2, 2, 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
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {8}, ngraph::element::u1, ngraph::element::u64, std::vector<uint8_t> {0x81},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {8}, ov::element::u1, ov::element::u64, std::vector<uint8_t> {0x81},
                       std::vector<uint64_t> {1, 0, 0, 0, 0, 0, 0, 1}, 8),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u4, ngraph::element::u64, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u4, ov::element::u64, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<uint64_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u8, ngraph::element::u64, std::vector<uint8_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u8, ov::element::u64, std::vector<uint8_t> {1, 2, 0, 3},
                       std::vector<uint64_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u16, ngraph::element::u64, std::vector<uint16_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u16, ov::element::u64, std::vector<uint16_t> {1, 2, 0, 3},
                       std::vector<uint64_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u32, ngraph::element::u64, std::vector<uint32_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u32, ov::element::u64, std::vector<uint32_t> {1, 2, 0, 3},
                       std::vector<uint64_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::u64, ngraph::element::u64, std::vector<uint64_t> {1, 2, 0, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::u64, ov::element::u64, std::vector<uint64_t> {1, 2, 0, 3},
                       std::vector<uint64_t> {1, 2, 0, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i4, ngraph::element::u64, std::vector<uint8_t> {0x21, 0x43},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i4, ov::element::u64, std::vector<uint8_t> {0x21, 0x43},
                       std::vector<uint64_t> {2, 1, 4, 3}, 4),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i8, ngraph::element::u64, std::vector<int8_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i8, ov::element::u64, std::vector<int8_t> {1, 2, 2, 3},
                       std::vector<uint64_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i16, ngraph::element::u64, std::vector<int16_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i16, ov::element::u64, std::vector<int16_t> {1, 2, 2, 3},
                       std::vector<uint64_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i32, ngraph::element::u64, std::vector<int32_t> {1, 2, 2, 3},
+        ConvertParams(ConversionTypes::CONVERT_LIKE, ov::PartialShape {4}, ov::element::i32, ov::element::u64, std::vector<int32_t> {1, 2, 2, 3},
                       std::vector<uint64_t> {1, 2, 2, 3}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::i64, ngraph::element::u64, std::vector<int64_t> {1, 2, 2, 3},
+        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, ngraph::PartialShape {4}, ngraph::element::f16, ngraph::element::u64,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::bf16, ngraph::element::u64,
+        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}),
-        ConvertParams(ConversionTypes::CONVERT_LIKE, ngraph::PartialShape {4}, ngraph::element::f32, ngraph::element::u64, std::vector<float> {1, 2, 2, 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);
 } // namespace
diff --git a/docs/template_plugin/tests/functional/op_reference/cos.cpp b/docs/template_plugin/tests/functional/op_reference/cos.cpp
index 13e9da49854..598f2f6075a 100644
--- a/docs/template_plugin/tests/functional/op_reference/cos.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/cos.cpp
@@ -4,15 +4,10 @@
 
 #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 "openvino/op/cos.hpp"
 #include "base_reference_test.hpp"
 
-using namespace ngraph;
+using namespace ov;
 
 namespace reference_tests {
 namespace {
@@ -45,9 +40,9 @@ public:
 
 private:
     static std::shared_ptr<Function> CreateFunction(const Shape& shape, const element::Type& type) {
-        const auto in = std::make_shared<op::Parameter>(type, shape);
-        const auto Cos = std::make_shared<op::Cos>(in);
-        return std::make_shared<Function>(NodeVector {Cos}, ParameterVector {in});
+        const auto in = std::make_shared<op::v0::Parameter>(type, shape);
+        const auto Cos = std::make_shared<op::v0::Cos>(in);
+        return std::make_shared<ov::Function>(NodeVector {Cos}, ParameterVector {in});
     }
 };
 
diff --git a/docs/template_plugin/tests/functional/op_reference/cosh.cpp b/docs/template_plugin/tests/functional/op_reference/cosh.cpp
index 94a66e96992..de1284c98c0 100644
--- a/docs/template_plugin/tests/functional/op_reference/cosh.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/cosh.cpp
@@ -4,15 +4,10 @@
 
 #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 "openvino/op/cosh.hpp"
 #include "base_reference_test.hpp"
 
-using namespace ngraph;
+using namespace ov;
 
 namespace reference_tests {
 namespace {
@@ -45,9 +40,9 @@ public:
 
 private:
     static std::shared_ptr<Function> CreateFunction(const Shape& shape, const element::Type& type) {
-        const auto in = std::make_shared<op::Parameter>(type, shape);
-        const auto Cosh = std::make_shared<op::Cosh>(in);
-        return std::make_shared<Function>(NodeVector {Cosh}, ParameterVector {in});
+        const auto in = std::make_shared<op::v0::Parameter>(type, shape);
+        const auto Cosh = std::make_shared<op::v0::Cosh>(in);
+        return std::make_shared<ov::Function>(NodeVector {Cosh}, ParameterVector {in});
     }
 };
 
diff --git a/docs/template_plugin/tests/functional/op_reference/ctc_loss.cpp b/docs/template_plugin/tests/functional/op_reference/ctc_loss.cpp
index 5579e17800f..08676053a82 100644
--- a/docs/template_plugin/tests/functional/op_reference/ctc_loss.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/ctc_loss.cpp
@@ -4,17 +4,11 @@
 
 #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 <tuple>
-
+#include "openvino/op/ctc_loss.hpp"
 #include "base_reference_test.hpp"
 
 using namespace reference_tests;
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 
 namespace {
 
@@ -68,14 +62,14 @@ public:
 
 private:
     static std::shared_ptr<Function> CreateFunction(const CTCLossParams& params) {
-        const auto A = std::make_shared<op::Parameter>(params.logits.type, params.logits.shape);        // logits
-        const auto B = std::make_shared<op::Parameter>(params.logitsLen.type, params.logitsLen.shape);  // logitsLen
-        const auto C = std::make_shared<op::Parameter>(params.labels.type, params.labels.shape);        // labels
-        const auto D = std::make_shared<op::Parameter>(params.labelsLen.type, params.labelsLen.shape);  // labelsLen
-        const auto E = std::make_shared<op::Parameter>(params.blankIdx.type, params.blankIdx.shape);    // blankIdx
+        const auto A = std::make_shared<op::v0::Parameter>(params.logits.type, params.logits.shape);        // logits
+        const auto B = std::make_shared<op::v0::Parameter>(params.logitsLen.type, params.logitsLen.shape);  // logitsLen
+        const auto C = std::make_shared<op::v0::Parameter>(params.labels.type, params.labels.shape);        // labels
+        const auto D = std::make_shared<op::v0::Parameter>(params.labelsLen.type, params.labelsLen.shape);  // labelsLen
+        const auto E = std::make_shared<op::v0::Parameter>(params.blankIdx.type, params.blankIdx.shape);    // blankIdx
 
         const auto ctcLoss = std::make_shared<op::v4::CTCLoss>(A, B, C, D, E, params.preprocessCollapseRepeated, params.ctcMergeRepeated, params.unique);
-        return std::make_shared<Function>(NodeVector {ctcLoss}, ParameterVector {A, B, C, D, E});
+        return std::make_shared<ov::Function>(NodeVector {ctcLoss}, ParameterVector {A, B, C, D, E});
     }
 };
 
diff --git a/docs/template_plugin/tests/functional/op_reference/cum_sum.cpp b/docs/template_plugin/tests/functional/op_reference/cum_sum.cpp
index e6a74c88f74..1f217dc7aef 100644
--- a/docs/template_plugin/tests/functional/op_reference/cum_sum.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/cum_sum.cpp
@@ -4,17 +4,11 @@
 
 #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 <tuple>
-
+#include "openvino/op/cum_sum.hpp"
 #include "base_reference_test.hpp"
 
 using namespace reference_tests;
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 
 namespace {
 struct CumSumParams {
@@ -30,9 +24,9 @@ struct CumSumParams {
           axisType(axisType),
           inType(iType),
           outType(iType),
-          axisData(CreateBlob(axisType, std::vector<AT> {axisVal})),
-          inputData(CreateBlob(iType, iValues)),
-          refData(CreateBlob(iType, oValues)),
+          axisData(CreateTensor(axisType, std::vector<AT> {axisVal})),
+          inputData(CreateTensor(iType, iValues)),
+          refData(CreateTensor(iType, oValues)),
           testDefaults(false) {}
 
     // Default axis input and attributes
@@ -42,8 +36,8 @@ struct CumSumParams {
           axisType(element::i32),
           inType(iType),
           outType(iType),
-          inputData(CreateBlob(iType, iValues)),
-          refData(CreateBlob(iType, oValues)),
+          inputData(CreateTensor(iType, iValues)),
+          refData(CreateTensor(iType, oValues)),
           testDefaults(true) {}
 
     bool execlusive = false;
@@ -93,16 +87,16 @@ public:
 private:
     static std::shared_ptr<Function> CreateFunction(const PartialShape& data_shape, const element::Type& data_type, const PartialShape& axis_shape,
                                                     const element::Type& axis_type, const bool execlusive, const bool reverse) {
-        const auto data_param = std::make_shared<op::Parameter>(data_type, data_shape);
-        const auto axis_param = std::make_shared<op::Parameter>(axis_type, axis_shape);
+        const auto data_param = std::make_shared<op::v0::Parameter>(data_type, data_shape);
+        const auto axis_param = std::make_shared<op::v0::Parameter>(axis_type, axis_shape);
         const auto cum_sum = std::make_shared<op::v0::CumSum>(data_param, axis_param, execlusive, reverse);
-        return std::make_shared<Function>(NodeVector {cum_sum}, ParameterVector {data_param, axis_param});
+        return std::make_shared<ov::Function>(NodeVector {cum_sum}, ParameterVector {data_param, axis_param});
     }
 
     static std::shared_ptr<Function> CreateFunction(const PartialShape& data_shape, const element::Type& data_type) {
-        const auto data_param = std::make_shared<op::Parameter>(data_type, data_shape);
+        const auto data_param = std::make_shared<op::v0::Parameter>(data_type, data_shape);
         const auto cum_sum = std::make_shared<op::v0::CumSum>(data_param);
-        return std::make_shared<Function>(NodeVector {cum_sum}, ParameterVector {data_param});
+        return std::make_shared<ov::Function>(NodeVector {cum_sum}, ParameterVector {data_param});
     }
 };
 
diff --git a/docs/template_plugin/tests/functional/op_reference/equal.cpp b/docs/template_plugin/tests/functional/op_reference/equal.cpp
index c4a2ba2b0f5..5ee1f2c2ff9 100644
--- a/docs/template_plugin/tests/functional/op_reference/equal.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/equal.cpp
@@ -4,18 +4,12 @@
 
 #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 "openvino/op/equal.hpp"
 #include "comparison.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using ComparisonTypes = ngraph::helpers::ComparisonTypes;
 
-
 namespace reference_tests {
 namespace ComparisonOpsRefTestDefinitions {
 namespace {
diff --git a/docs/template_plugin/tests/functional/op_reference/erf.cpp b/docs/template_plugin/tests/functional/op_reference/erf.cpp
index ffcbcea13a8..f966355c994 100644
--- a/docs/template_plugin/tests/functional/op_reference/erf.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/erf.cpp
@@ -4,23 +4,16 @@
 
 #include <gtest/gtest.h>
 
-#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 <tuple>
-
+#include "openvino/op/erf.hpp"
 #include "base_reference_test.hpp"
 
 using namespace reference_tests;
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 
 struct ErfParams {
     template <class IT>
-    ErfParams(const ngraph::PartialShape& shape, const ngraph::element::Type& iType, const std::vector<IT>& iValues)
-        : pshape(shape), inType(iType), outType(iType), inputData(CreateBlob(iType, iValues)) {
+    ErfParams(const ov::PartialShape& shape, const ov::element::Type& iType, const std::vector<IT>& iValues)
+        : pshape(shape), inType(iType), outType(iType), inputData(CreateTensor(iType, iValues)) {
         std::vector<IT> oValues;
         std::vector<double> output;
         for (auto element : iValues)
@@ -38,11 +31,11 @@ struct ErfParams {
 
         for (auto element : output)
             oValues.push_back(static_cast<IT>(element));
-        refData = CreateBlob(outType, oValues);
+        refData = CreateTensor(outType, oValues);
     }
-    ngraph::PartialShape pshape;
-    ngraph::element::Type inType;
-    ngraph::element::Type outType;
+    ov::PartialShape pshape;
+    ov::element::Type inType;
+    ov::element::Type outType;
     ov::runtime::Tensor inputData;
     ov::runtime::Tensor refData;
 };
@@ -67,9 +60,9 @@ public:
 private:
     static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape, const element::Type& input_type,
                                                     const element::Type& expected_output_type) {
-        const auto in = std::make_shared<op::Parameter>(input_type, input_shape);
-        const auto erf = std::make_shared<op::Erf>(in);
-        return std::make_shared<Function>(NodeVector {erf}, ParameterVector {in});
+        const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
+        const auto erf = std::make_shared<op::v0::Erf>(in);
+        return std::make_shared<ov::Function>(NodeVector {erf}, ParameterVector {in});
     }
 };
 
@@ -79,16 +72,16 @@ TEST_P(ReferenceErfLayerTest, CompareWithRefs) {
 
 INSTANTIATE_TEST_SUITE_P(
     smoke_Erf_With_Hardcoded_Refs, ReferenceErfLayerTest,
-    ::testing::Values(ErfParams(ngraph::PartialShape {2, 5}, ngraph::element::f32,
+    ::testing::Values(ErfParams(ov::PartialShape {2, 5}, ov::element::f32,
                                 std::vector<float> {-INFINITY, -4.0f, -3.0f, -2.0f, -1.0f, 0.0f, 1.0f, 2.0f, 3.0f, INFINITY}),
-                      ErfParams(ngraph::PartialShape {2, 5}, ngraph::element::f16,
+                      ErfParams(ov::PartialShape {2, 5}, ov::element::f16,
                                 std::vector<float16> {-INFINITY, -4.0f, -3.0f, -2.0f, -1.0f, 0.0f, 1.0f, 2.0f, 3.0f, INFINITY}),
-                      ErfParams(ngraph::PartialShape {2, 3}, ngraph::element::i32,
+                      ErfParams(ov::PartialShape {2, 3}, ov::element::i32,
                                 std::vector<int32_t> {std::numeric_limits<int32_t>::min(), -2, -1, 1, 2, std::numeric_limits<int32_t>::max()}),
-                      ErfParams(ngraph::PartialShape {2, 3}, ngraph::element::u32,
+                      ErfParams(ov::PartialShape {2, 3}, ov::element::u32,
                                 std::vector<uint32_t> {std::numeric_limits<uint32_t>::min(), 0, 1, 2, 3, std::numeric_limits<uint32_t>::max()}),
-                      ErfParams(ngraph::PartialShape {2, 3}, ngraph::element::i64,
+                      ErfParams(ov::PartialShape {2, 3}, ov::element::i64,
                                 std::vector<int64_t> {std::numeric_limits<int64_t>::min(), -2, -1, 1, 2, std::numeric_limits<int64_t>::max()}),
-                      ErfParams(ngraph::PartialShape {2, 3}, ngraph::element::u64,
+                      ErfParams(ov::PartialShape {2, 3}, ov::element::u64,
                                 std::vector<uint64_t> {std::numeric_limits<uint64_t>::min(), 0, 1, 2, 3, std::numeric_limits<uint64_t>::max()})),
     ReferenceErfLayerTest::getTestCaseName);
diff --git a/docs/template_plugin/tests/functional/op_reference/experimental_detectron_roi_feature_extractor.cpp b/docs/template_plugin/tests/functional/op_reference/experimental_detectron_roi_feature_extractor.cpp
index 43fc4c9a59d..9e8f5f91f86 100644
--- a/docs/template_plugin/tests/functional/op_reference/experimental_detectron_roi_feature_extractor.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/experimental_detectron_roi_feature_extractor.cpp
@@ -4,16 +4,10 @@
 
 #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 <tuple>
-
+#include "openvino/op/experimental_detectron_roi_feature.hpp"
 #include "base_reference_test.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using namespace reference_tests;
 
 struct ExperimentalROIParams {
@@ -62,13 +56,13 @@ private:
         ParameterVector parameter_vector(num_of_inputs);
         for (size_t i = 0; i < num_of_inputs; ++i) {
             const auto& current_input = inputs[i];
-            auto current_parameter = std::make_shared<op::Parameter>(current_input.type, current_input.shape);
+            auto current_parameter = std::make_shared<op::v0::Parameter>(current_input.type, current_input.shape);
             node_vector[i] = current_parameter;
             parameter_vector[i] = current_parameter;
         }
 
         auto roi = std::make_shared<op::v6::ExperimentalDetectronROIFeatureExtractor>(node_vector, attrs);
-        auto fun = std::make_shared<Function>(OutputVector{roi->output(0), roi->output(1)}, parameter_vector);
+        auto fun = std::make_shared<ov::Function>(OutputVector{roi->output(0), roi->output(1)}, parameter_vector);
         return fun;
     }
 };
@@ -83,13 +77,13 @@ INSTANTIATE_TEST_SUITE_P(
     ::testing::Values(
         ExperimentalROIParams(
             std::vector<Tensor>{Tensor(Shape{2, 4},
-                                       ngraph::element::f32,
+                                       ov::element::f32,
                                        std::vector<float>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0}),
                                 Tensor(Shape{1, 2, 2, 3},
-                                       ngraph::element::f32,
+                                       ov::element::f32,
                                        std::vector<float>{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<Tensor>{Tensor(Shape{2, 2, 3, 3},
-                                       ngraph::element::f32,
+                                       ov::element::f32,
                                        std::vector<float>{1.416667,
                                                           1.75,
                                                           2.083333,
@@ -127,18 +121,18 @@ INSTANTIATE_TEST_SUITE_P(
                                                           5.25,
                                                           5.416667}),
                                 Tensor(Shape{2, 4},
-                                       ngraph::element::f32,
+                                       ov::element::f32,
                                        std::vector<float>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0})},
             "experimental_detectron_roi_feature_eval_f32"),
         ExperimentalROIParams(
             std::vector<Tensor>{Tensor(Shape{2, 4},
-                                       ngraph::element::f16,
+                                       ov::element::f16,
                                        std::vector<ngraph::float16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0}),
                                 Tensor(Shape{1, 2, 2, 3},
-                                       ngraph::element::f16,
+                                       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<Tensor>{Tensor(Shape{2, 2, 3, 3},
-                                       ngraph::element::f16,
+                                       ov::element::f16,
                                        std::vector<ngraph::float16>{1.416667,
                                                                     1.75,
                                                                     2.083333,
@@ -176,18 +170,18 @@ INSTANTIATE_TEST_SUITE_P(
                                                                     5.25,
                                                                     5.416667}),
                                 Tensor(Shape{2, 4},
-                                       ngraph::element::f16,
+                                       ov::element::f16,
                                        std::vector<ngraph::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<Tensor>{Tensor(Shape{2, 4},
-                                       ngraph::element::bf16,
+                                       ov::element::bf16,
                                        std::vector<ngraph::bfloat16>{0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0}),
                                 Tensor(Shape{1, 2, 2, 3},
-                                       ngraph::element::bf16,
+                                       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<Tensor>{Tensor(Shape{2, 2, 3, 3},
-                                       ngraph::element::bf16,
+                                       ov::element::bf16,
                                        std::vector<ngraph::bfloat16>{1.416667,
                                                                      1.75,
                                                                      2.083333,
@@ -225,6 +219,6 @@ INSTANTIATE_TEST_SUITE_P(
                                                                      5.25,
                                                                      5.416667}),
                                 Tensor(Shape{2, 4},
-                                       ngraph::element::bf16,
+                                       ov::element::bf16,
                                        std::vector<ngraph::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/docs/template_plugin/tests/functional/op_reference/gather_tree.cpp b/docs/template_plugin/tests/functional/op_reference/gather_tree.cpp
index 412848f3a9e..cb401f1b1f9 100644
--- a/docs/template_plugin/tests/functional/op_reference/gather_tree.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/gather_tree.cpp
@@ -4,26 +4,19 @@
 
 #include <gtest/gtest.h>
 
-#include <ie_core.hpp>
-#include <ie_ngraph_utils.hpp>
-#include <limits>
-#include <algorithm>
-#include <ngraph/ngraph.hpp>
-#include <shared_test_classes/base/layer_test_utils.hpp>
-
+#include "openvino/op/gather_tree.hpp"
 #include "base_reference_test.hpp"
 
 using namespace reference_tests;
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 
 namespace {
 struct GatherTreeParams {
     template <class IN_ET>
-    GatherTreeParams(const ngraph::Shape inShape, std::vector<IN_ET> stepIds, const std::vector<IN_ET> parentIds,
+    GatherTreeParams(const ov::Shape inShape, std::vector<IN_ET> stepIds, const std::vector<IN_ET> parentIds,
         const std::vector<IN_ET> maxSeqLen, const std::vector<IN_ET> endToken, std::vector<IN_ET> output) :
         stepIdsTensor(inShape, element::from<IN_ET>(), stepIds), parentIdsTensor(inShape, element::from<IN_ET>(), parentIds),
-        maxSeqLenTensor(ngraph::Shape{inShape[1]}, element::from<IN_ET>(), maxSeqLen), endTokenTensor(ngraph::Shape{}, element::from<IN_ET>(), endToken),
+        maxSeqLenTensor(ov::Shape{inShape[1]}, element::from<IN_ET>(), maxSeqLen), endTokenTensor(ov::Shape{}, element::from<IN_ET>(), endToken),
         expectedTensor(inShape, element::from<IN_ET>(), output) {}
     Tensor stepIdsTensor;
     Tensor parentIdsTensor;
@@ -50,12 +43,12 @@ public:
 
 private:
     static std::shared_ptr<Function> CreateFunction(const GatherTreeParams& params) {
-        const auto stepIds = std::make_shared<op::Parameter>(params.stepIdsTensor.type, params.stepIdsTensor.shape);
-        const auto parentIds = std::make_shared<op::Parameter>(params.parentIdsTensor.type, params.parentIdsTensor.shape);
-        const auto maxSeqLen = std::make_shared<op::Parameter>(params.maxSeqLenTensor.type, params.maxSeqLenTensor.shape);
-        const auto endToken = std::make_shared<op::Parameter>(params.endTokenTensor.type, params.endTokenTensor.shape);
+        const auto stepIds = std::make_shared<op::v0::Parameter>(params.stepIdsTensor.type, params.stepIdsTensor.shape);
+        const auto parentIds = std::make_shared<op::v0::Parameter>(params.parentIdsTensor.type, params.parentIdsTensor.shape);
+        const auto maxSeqLen = std::make_shared<op::v0::Parameter>(params.maxSeqLenTensor.type, params.maxSeqLenTensor.shape);
+        const auto endToken = std::make_shared<op::v0::Parameter>(params.endTokenTensor.type, params.endTokenTensor.shape);
         const auto gatherTree = std::make_shared<op::v1::GatherTree>(stepIds, parentIds, maxSeqLen, endToken);
-        return std::make_shared<Function>(NodeVector {gatherTree}, ParameterVector {stepIds, parentIds, maxSeqLen, endToken});
+        return std::make_shared<ov::Function>(NodeVector {gatherTree}, ParameterVector {stepIds, parentIds, maxSeqLen, endToken});
     }
 };
 
diff --git a/docs/template_plugin/tests/functional/op_reference/greater.cpp b/docs/template_plugin/tests/functional/op_reference/greater.cpp
index c08a46ccda8..c23479fbd7b 100644
--- a/docs/template_plugin/tests/functional/op_reference/greater.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/greater.cpp
@@ -4,15 +4,10 @@
 
 #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 "openvino/op/greater.hpp"
 #include "comparison.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using ComparisonTypes = ngraph::helpers::ComparisonTypes;
 
 namespace reference_tests {
diff --git a/docs/template_plugin/tests/functional/op_reference/greater_equal.cpp b/docs/template_plugin/tests/functional/op_reference/greater_equal.cpp
index 0e609fb4f74..5ef3a86c810 100644
--- a/docs/template_plugin/tests/functional/op_reference/greater_equal.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/greater_equal.cpp
@@ -4,15 +4,10 @@
 
 #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 "openvino/op/greater_eq.hpp"
 #include "comparison.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using ComparisonTypes = ngraph::helpers::ComparisonTypes;
 
 namespace reference_tests {
diff --git a/docs/template_plugin/tests/functional/op_reference/grn.cpp b/docs/template_plugin/tests/functional/op_reference/grn.cpp
index 3bf96a9769c..38d15d4a2da 100644
--- a/docs/template_plugin/tests/functional/op_reference/grn.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/grn.cpp
@@ -4,24 +4,18 @@
 
 #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 <tuple>
-
+#include "openvino/op/grn.hpp"
 #include "base_reference_test.hpp"
 
 using namespace reference_tests;
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 
 namespace {
 struct GrnParams {
     template <class IT>
     GrnParams(const float bias, const PartialShape& shape, const element::Type& iType, const std::vector<IT>& iValues,
               const std::vector<IT>& oValues)
-        : bias(bias), pshape(shape), inType(iType), outType(iType), inputData(CreateBlob(iType, iValues)), refData(CreateBlob(iType, oValues)) {}
+        : bias(bias), pshape(shape), inType(iType), outType(iType), inputData(CreateTensor(iType, iValues)), refData(CreateTensor(iType, oValues)) {}
     float bias;
     PartialShape pshape;
     element::Type inType;
@@ -50,9 +44,9 @@ public:
 
 private:
     static std::shared_ptr<Function> CreateFunction(float bias, const PartialShape& input_shape, const element::Type& input_type) {
-        const auto in = std::make_shared<op::Parameter>(input_type, input_shape);
+        const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
         const auto grn = std::make_shared<op::v0::GRN>(in, bias);
-        return std::make_shared<Function>(NodeVector {grn}, ParameterVector {in});
+        return std::make_shared<ov::Function>(NodeVector {grn}, ParameterVector {in});
     }
 };
 
diff --git a/docs/template_plugin/tests/functional/op_reference/less.cpp b/docs/template_plugin/tests/functional/op_reference/less.cpp
index 87feca926a3..038752d3481 100644
--- a/docs/template_plugin/tests/functional/op_reference/less.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/less.cpp
@@ -4,15 +4,10 @@
 
 #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 "openvino/op/less.hpp"
 #include "comparison.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using ComparisonTypes = ngraph::helpers::ComparisonTypes;
 
 namespace reference_tests {
diff --git a/docs/template_plugin/tests/functional/op_reference/less_eq.cpp b/docs/template_plugin/tests/functional/op_reference/less_eq.cpp
index 028ef909f67..2114957fc93 100644
--- a/docs/template_plugin/tests/functional/op_reference/less_eq.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/less_eq.cpp
@@ -4,15 +4,10 @@
 
 #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 "openvino/op/less_eq.hpp"
 #include "comparison.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using ComparisonTypes = ngraph::helpers::ComparisonTypes;
 
 namespace reference_tests {
diff --git a/docs/template_plugin/tests/functional/op_reference/logical.hpp b/docs/template_plugin/tests/functional/op_reference/logical.hpp
index ee681f36141..49978a6b1a1 100644
--- a/docs/template_plugin/tests/functional/op_reference/logical.hpp
+++ b/docs/template_plugin/tests/functional/op_reference/logical.hpp
@@ -4,15 +4,11 @@
 
 #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"
 
+using namespace ov;
+
 namespace reference_tests {
 namespace LogicalOpsRefTestDefinitions {
 
@@ -52,14 +48,14 @@ public:
     }
 
 private:
-    static std::shared_ptr<ngraph::Function> CreateFunction(ngraph::helpers::LogicalTypes op_type, const std::vector<Tensor>& inputs) {
-        ngraph::ParameterVector params_vec;
+    static std::shared_ptr<ov::Function> CreateFunction(ngraph::helpers::LogicalTypes op_type, const std::vector<Tensor>& inputs) {
+        ov::ParameterVector params_vec;
         for (auto& input : inputs) {
-            params_vec.push_back(std::make_shared<ngraph::op::Parameter>(input.type, input.shape));
+            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);
-        return std::make_shared<ngraph::Function>(ngraph::NodeVector {logical_op}, ngraph::ParameterVector {params_vec});
+        return std::make_shared<ov::Function>(ov::NodeVector {logical_op}, ov::ParameterVector {params_vec});
     }
 };
 }  // namespace LogicalOpsRefTestDefinitions
diff --git a/docs/template_plugin/tests/functional/op_reference/logical_and.cpp b/docs/template_plugin/tests/functional/op_reference/logical_and.cpp
index 0d1db90e21a..4c6fe9894db 100644
--- a/docs/template_plugin/tests/functional/op_reference/logical_and.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/logical_and.cpp
@@ -4,16 +4,10 @@
 
 #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 <tuple>
-
+#include "openvino/op/logical_and.hpp"
 #include "logical.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using LogicalTypes = ngraph::helpers::LogicalTypes;
 
 namespace reference_tests {
diff --git a/docs/template_plugin/tests/functional/op_reference/logical_not.cpp b/docs/template_plugin/tests/functional/op_reference/logical_not.cpp
index 3bcfa3c6ba8..ce87f37c3b4 100644
--- a/docs/template_plugin/tests/functional/op_reference/logical_not.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/logical_not.cpp
@@ -4,16 +4,10 @@
 
 #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 <tuple>
-
+#include "openvino/op/logical_not.hpp"
 #include "logical.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using LogicalTypes = ngraph::helpers::LogicalTypes;
 
 namespace reference_tests {
diff --git a/docs/template_plugin/tests/functional/op_reference/logical_or.cpp b/docs/template_plugin/tests/functional/op_reference/logical_or.cpp
index e8c28f24468..5c7b03831ce 100644
--- a/docs/template_plugin/tests/functional/op_reference/logical_or.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/logical_or.cpp
@@ -4,16 +4,10 @@
 
 #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 <tuple>
-
+#include "openvino/op/logical_or.hpp"
 #include "logical.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using LogicalTypes = ngraph::helpers::LogicalTypes;
 
 namespace reference_tests {
diff --git a/docs/template_plugin/tests/functional/op_reference/logical_xor.cpp b/docs/template_plugin/tests/functional/op_reference/logical_xor.cpp
index 52269ddb894..813fe9b5e74 100644
--- a/docs/template_plugin/tests/functional/op_reference/logical_xor.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/logical_xor.cpp
@@ -4,16 +4,10 @@
 
 #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 <tuple>
-
+#include "openvino/op/logical_xor.hpp"
 #include "logical.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using LogicalTypes = ngraph::helpers::LogicalTypes;
 
 namespace reference_tests {
diff --git a/docs/template_plugin/tests/functional/op_reference/max_pool.cpp b/docs/template_plugin/tests/functional/op_reference/max_pool.cpp
index 1cbe103b9bc..120bda1e4b8 100644
--- a/docs/template_plugin/tests/functional/op_reference/max_pool.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/max_pool.cpp
@@ -4,17 +4,11 @@
 
 #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 <tuple>
-
+#include "openvino/op/max_pool.hpp"
 #include "base_reference_test.hpp"
 
-using namespace ngraph;
 using namespace reference_tests;
-using namespace InferenceEngine;
+using namespace ov;
 
 struct MaxPoolParams {
     template <class Input_t, class Indices_t>
@@ -34,9 +28,9 @@ struct MaxPoolParams {
         : m_input_shape(input_shape),
           m_input_type(input_type),
           m_indices_type(indices_type),
-          m_input_data(CreateBlob(input_type, input_data)),
-          m_expected_values(CreateBlob(input_type, expected_values)),
-          m_expected_indices(CreateBlob(indices_type, expected_indices)),
+          m_input_data(CreateTensor(input_type, input_data)),
+          m_expected_values(CreateTensor(input_type, expected_values)),
+          m_expected_indices(CreateTensor(indices_type, expected_indices)),
           m_strides(strides),
           m_dilations(dilations),
           m_pads_begin(pads_begin),
@@ -86,7 +80,7 @@ public:
 
 private:
     static std::shared_ptr<Function> CreateFunction(const MaxPoolParams& params) {
-        const auto in = std::make_shared<op::Parameter>(params.m_input_type, params.m_input_shape);
+        const auto in = std::make_shared<op::v0::Parameter>(params.m_input_type, params.m_input_shape);
         const auto max_pool = std::make_shared<op::v8::MaxPool>(in,
                                                                 params.m_strides,
                                                                 params.m_dilations,
@@ -97,7 +91,7 @@ private:
                                                                 params.m_pad_type,
                                                                 params.m_indices_type,
                                                                 params.m_axis);
-        return std::make_shared<Function>(max_pool, ParameterVector{in});
+        return std::make_shared<ov::Function>(max_pool, ParameterVector{in});
     }
 };
 
diff --git a/docs/template_plugin/tests/functional/op_reference/minimum.cpp b/docs/template_plugin/tests/functional/op_reference/minimum.cpp
index a42d1eca1e3..730e02cc87b 100644
--- a/docs/template_plugin/tests/functional/op_reference/minimum.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/minimum.cpp
@@ -4,16 +4,10 @@
 
 #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 <tuple>
-
+#include "openvino/op/minimum.hpp"
 #include "base_reference_test.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using namespace reference_tests;
 
 struct MinimumParams {
@@ -25,9 +19,9 @@ struct MinimumParams {
         : pshape(s),
           inType(iType),
           outType(oType),
-          inputData1(CreateBlob(iType, iValues1)),
-          inputData2(CreateBlob(iType, iValues2)),
-          refData(CreateBlob(oType, oValues)) {}
+          inputData1(CreateTensor(iType, iValues1)),
+          inputData2(CreateTensor(iType, iValues2)),
+          refData(CreateTensor(oType, oValues)) {}
     PartialShape pshape;
     element::Type inType;
     element::Type outType;
@@ -55,9 +49,9 @@ public:
 
 private:
     static std::shared_ptr<Function> CreateFunction(const PartialShape& shape, const element::Type& data_type) {
-        auto A = std::make_shared<op::Parameter>(data_type, shape);
-        auto B = std::make_shared<op::Parameter>(data_type, shape);
-        return std::make_shared<Function>(std::make_shared<op::v1::Minimum>(A, B), ParameterVector{A, B});
+        auto A = std::make_shared<op::v0::Parameter>(data_type, shape);
+        auto B = std::make_shared<op::v0::Parameter>(data_type, shape);
+        return std::make_shared<ov::Function>(std::make_shared<op::v1::Minimum>(A, B), ParameterVector{A, B});
     }
 };
 
diff --git a/docs/template_plugin/tests/functional/op_reference/mvn.cpp b/docs/template_plugin/tests/functional/op_reference/mvn.cpp
index 7ba1258ab0f..137e4214114 100644
--- a/docs/template_plugin/tests/functional/op_reference/mvn.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/mvn.cpp
@@ -4,16 +4,11 @@
 
 #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 <tuple>
-
+#include "openvino/op/mvn.hpp"
 #include "base_reference_test.hpp"
+#include "shared_test_classes/base/layer_test_utils.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using namespace reference_tests;
 
 // ------------------------------ V0 ------------------------------
@@ -61,12 +56,12 @@ public:
 private:
     static std::shared_ptr<Function> CreateFunction(const Tensor& input, const ngraph::AxisSet& reductionAxes, const bool acrossChannels,
                                                     const bool normalizeVariance, const double eps) {
-        const auto in = std::make_shared<op::Parameter>(input.type, input.shape);
-        auto mvn = std::make_shared<op::MVN>(in, acrossChannels, normalizeVariance, 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);
         if (!reductionAxes.empty()) {
-            mvn = std::make_shared<op::MVN>(in, reductionAxes, normalizeVariance, eps);
+            mvn = std::make_shared<op::v0::MVN>(in, reductionAxes, normalizeVariance, eps);
         }
-        return std::make_shared<Function>(NodeVector {mvn}, ParameterVector {in});
+        return std::make_shared<ov::Function>(NodeVector {mvn}, ParameterVector {in});
     }
 };
 
@@ -80,63 +75,63 @@ INSTANTIATE_TEST_SUITE_P(
     smoke_MVN1_With_Hardcoded_Refs, ReferenceMVN1LayerTest,
     ::testing::Values(
         // across_channels=false, variance=false
-        MVN1Params(Tensor {{1, 3, 3, 3}, ngraph::element::f32, std::vector<float> {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5,
+        MVN1Params(Tensor {{1, 3, 3, 3}, ov::element::f32, std::vector<float> {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5,
                                                                                    6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9}},
                    emptyReductionAxes,
                    false,
                    false,
                    1e-9,
-                   Tensor {{1, 3, 3, 3}, ngraph::element::f32, std::vector<float> {-4, -3, -2, -1, 0,  1,  2,  3,  4, -4, -3, -2, -1, 0,
+                   Tensor {{1, 3, 3, 3}, ov::element::f32, std::vector<float> {-4, -3, -2, -1, 0,  1,  2,  3,  4, -4, -3, -2, -1, 0,
                                                                                    1,  2,  3,  4,  -4, -3, -2, -1, 0, 1,  2,  3,  4}}),
         // across_channels=true, variance=false
         MVN1Params(
-            Tensor {{1, 3, 2, 2}, ngraph::element::f32, std::vector<float> {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3}},
+            Tensor {{1, 3, 2, 2}, ov::element::f32, std::vector<float> {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3}},
             emptyReductionAxes,
             true,
             false,
             1e-9,
-            Tensor {{1, 3, 2, 2}, ngraph::element::f32, std::vector<float> {-3.25, -2.25, -1.25, -0.25, 0.75, 1.75, 2.75, 3.75, 4.75, -3.25, -2.25, -1.25}}),
+            Tensor {{1, 3, 2, 2}, ov::element::f32, std::vector<float> {-3.25, -2.25, -1.25, -0.25, 0.75, 1.75, 2.75, 3.75, 4.75, -3.25, -2.25, -1.25}}),
         // across_channels=false, variance=true
-        MVN1Params(Tensor {{1, 3, 3, 3}, ngraph::element::f32, std::vector<float> {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5,
+        MVN1Params(Tensor {{1, 3, 3, 3}, ov::element::f32, std::vector<float> {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5,
                                                                                    6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9}},
                    emptyReductionAxes,
                    false,
                    true,
                    1e-9,
                    Tensor {{1, 3, 3, 3},
-                           ngraph::element::f32,
+                           ov::element::f32,
                            std::vector<float> {-1.5491934, -1.161895, -0.7745967, -0.38729835, 0., 0.38729835, 0.7745967, 1.161895, 1.5491934,
                                                -1.5491934, -1.161895, -0.7745967, -0.38729835, 0., 0.38729835, 0.7745967, 1.161895, 1.5491934,
                                                -1.5491934, -1.161895, -0.7745967, -0.38729835, 0., 0.38729835, 0.7745967, 1.161895, 1.5491934}}),
         // across_channels=true, variance=true
-        MVN1Params(Tensor {{1, 3, 3, 3}, ngraph::element::f32, std::vector<float> {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5,
+        MVN1Params(Tensor {{1, 3, 3, 3}, ov::element::f32, std::vector<float> {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5,
                                                                                    6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9}},
                    emptyReductionAxes,
                    true,
                    true,
                    1e-9,
                    Tensor {{1, 3, 3, 3},
-                           ngraph::element::f32,
+                           ov::element::f32,
                            std::vector<float> {-1.5491934, -1.161895, -0.7745967, -0.38729835, 0., 0.38729835, 0.7745967, 1.161895, 1.5491934,
                                                -1.5491934, -1.161895, -0.7745967, -0.38729835, 0., 0.38729835, 0.7745967, 1.161895, 1.5491934,
                                                -1.5491934, -1.161895, -0.7745967, -0.38729835, 0., 0.38729835, 0.7745967, 1.161895, 1.5491934}}),
         // reductionAxes, variance=false
         MVN1Params(
-            Tensor {{1, 3, 2, 2}, ngraph::element::f32, std::vector<float> {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3}},
+            Tensor {{1, 3, 2, 2}, ov::element::f32, std::vector<float> {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3}},
             {1, 2, 3},
             false,
             false,
             1e-9,
-            Tensor {{1, 3, 2, 2}, ngraph::element::f32, std::vector<float> {-3.25, -2.25, -1.25, -0.25, 0.75, 1.75, 2.75, 3.75, 4.75, -3.25, -2.25, -1.25}}),
+            Tensor {{1, 3, 2, 2}, ov::element::f32, std::vector<float> {-3.25, -2.25, -1.25, -0.25, 0.75, 1.75, 2.75, 3.75, 4.75, -3.25, -2.25, -1.25}}),
         // reductionAxes, variance=true
-        MVN1Params(Tensor {{1, 3, 3, 3}, ngraph::element::f32, std::vector<float> {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5,
+        MVN1Params(Tensor {{1, 3, 3, 3}, ov::element::f32, std::vector<float> {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5,
                                                                                    6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9}},
                    {2, 3},
                    false,
                    true,
                    1e-9,
                    Tensor {{1, 3, 3, 3},
-                           ngraph::element::f32,
+                           ov::element::f32,
                            std::vector<float> {-1.5491934, -1.161895, -0.7745967, -0.38729835, 0., 0.38729835, 0.7745967, 1.161895, 1.5491934,
                                                -1.5491934, -1.161895, -0.7745967, -0.38729835, 0., 0.38729835, 0.7745967, 1.161895, 1.5491934,
                                                -1.5491934, -1.161895, -0.7745967, -0.38729835, 0., 0.38729835, 0.7745967, 1.161895, 1.5491934}})),
@@ -146,7 +141,7 @@ INSTANTIATE_TEST_SUITE_P(
 
 struct MVN6Params {
     MVN6Params(const Tensor& paramInput, const Tensor& paramReductionAxes, const bool paramNormalizeVariance, const double paramEps,
-               const ngraph::op::MVNEpsMode mode, const Tensor& paramExpected)
+               const op::MVNEpsMode mode, const Tensor& paramExpected)
         : input(paramInput),
           reductionAxes(paramReductionAxes),
           normalizeVariance(paramNormalizeVariance),
@@ -157,7 +152,7 @@ struct MVN6Params {
     Tensor reductionAxes;
     bool normalizeVariance;
     double eps;
-    ngraph::op::MVNEpsMode epsMode;
+    op::MVNEpsMode epsMode;
     Tensor expected;
 };
 
@@ -183,16 +178,16 @@ public:
 
 private:
     static std::shared_ptr<Function> CreateFunction(const Tensor& input, const Tensor& reductionAxes, const bool normalizeVariance, const double eps,
-                                                    const ngraph::op::MVNEpsMode epsMode) {
+                                                    const op::MVNEpsMode epsMode) {
         std::vector<int64_t> dataVector(reductionAxes.shape[0]);
-        const auto in = std::make_shared<op::Parameter>(input.type, input.shape);
+        const auto in = std::make_shared<op::v0::Parameter>(input.type, input.shape);
         const auto refBuffer = reductionAxes.data.data<const std::int64_t>();
         for (size_t i = 0; i < dataVector.size(); ++i) {
             dataVector[i] = refBuffer[i];
         }
-        const auto axes = std::make_shared<op::Constant>(reductionAxes.type, reductionAxes.shape, dataVector);
+        const auto axes = std::make_shared<op::v0::Constant>(reductionAxes.type, reductionAxes.shape, dataVector);
         auto mvn = std::make_shared<op::v6::MVN>(in, axes, normalizeVariance, eps, epsMode);
-        return std::make_shared<Function>(NodeVector {mvn}, ParameterVector {in});
+        return std::make_shared<ov::Function>(NodeVector {mvn}, ParameterVector {in});
     }
 };
 
@@ -204,47 +199,47 @@ INSTANTIATE_TEST_SUITE_P(
     smoke_MVN6_With_Hardcoded_Refs, ReferenceMVN6LayerTest,
     ::testing::Values(
         // variance=false, OUTSIDE_SQRT
-        MVN6Params(Tensor {{1, 3, 3, 3}, ngraph::element::f32, std::vector<float> {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5,
+        MVN6Params(Tensor {{1, 3, 3, 3}, ov::element::f32, std::vector<float> {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5,
                                                                                    6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9}},
-                   Tensor {Shape {2}, ngraph::element::i64, std::vector<int64_t> {2, 3}},
+                   Tensor {Shape {2}, ov::element::i64, std::vector<int64_t> {2, 3}},
                    false,
                    1e-9,
-                   ngraph::op::MVNEpsMode::OUTSIDE_SQRT,
-                   Tensor {{1, 3, 3, 3}, ngraph::element::f32, std::vector<float> {-4, -3, -2, -1, 0,  1,  2,  3,  4, -4, -3, -2, -1, 0,
+                   op::MVNEpsMode::OUTSIDE_SQRT,
+                   Tensor {{1, 3, 3, 3}, ov::element::f32, std::vector<float> {-4, -3, -2, -1, 0,  1,  2,  3,  4, -4, -3, -2, -1, 0,
                                                                                    1,  2,  3,  4,  -4, -3, -2, -1, 0, 1,  2,  3,  4}}),
         // variance=true, OUTSIDE_SQRT
-        MVN6Params(Tensor {{1, 3, 3, 3}, ngraph::element::f32, std::vector<float> {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5,
+        MVN6Params(Tensor {{1, 3, 3, 3}, ov::element::f32, std::vector<float> {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5,
                                                                                    6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9}},
-                   Tensor {Shape {2}, ngraph::element::i64, std::vector<int64_t> {2, 3}},
+                   Tensor {Shape {2}, ov::element::i64, std::vector<int64_t> {2, 3}},
                    true,
                    1e-9,
-                   ngraph::op::MVNEpsMode::OUTSIDE_SQRT,
+                   op::MVNEpsMode::OUTSIDE_SQRT,
                    Tensor {{1, 3, 3, 3},
-                           ngraph::element::f32,
+                           ov::element::f32,
                            std::vector<float> {-1.5491934, -1.161895, -0.7745967, -0.38729835, 0., 0.38729835, 0.7745967, 1.161895, 1.5491934,
                                                -1.5491934, -1.161895, -0.7745967, -0.38729835, 0., 0.38729835, 0.7745967, 1.161895, 1.5491934,
                                                -1.5491934, -1.161895, -0.7745967, -0.38729835, 0., 0.38729835, 0.7745967, 1.161895, 1.5491934}}),
         // variance=true, INSIDE_SQRT
-        MVN6Params(Tensor {{1, 3, 3, 3}, ngraph::element::f32, std::vector<float> {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5,
+        MVN6Params(Tensor {{1, 3, 3, 3}, ov::element::f32, std::vector<float> {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5,
                                                                                    6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9}},
-                   Tensor {Shape {2}, ngraph::element::i64, std::vector<int64_t> {2, 3}},
+                   Tensor {Shape {2}, ov::element::i64, std::vector<int64_t> {2, 3}},
                    true,
                    1e-9,
-                   ngraph::op::MVNEpsMode::INSIDE_SQRT,
+                   op::MVNEpsMode::INSIDE_SQRT,
                    Tensor {{1, 3, 3, 3},
-                           ngraph::element::f32,
+                           ov::element::f32,
                            std::vector<float> {-1.5491934, -1.161895, -0.7745967, -0.38729835, 0., 0.38729835, 0.7745967, 1.161895, 1.5491934,
                                                -1.5491934, -1.161895, -0.7745967, -0.38729835, 0., 0.38729835, 0.7745967, 1.161895, 1.5491934,
                                                -1.5491934, -1.161895, -0.7745967, -0.38729835, 0., 0.38729835, 0.7745967, 1.161895, 1.5491934}}),
         // variance=true, another reductionAxes, OUTSIDE_SQRT
-        MVN6Params(Tensor {{1, 3, 3, 3}, ngraph::element::f32, std::vector<float>({1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5,
+        MVN6Params(Tensor {{1, 3, 3, 3}, ov::element::f32, std::vector<float>({1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5,
                                                                                    6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9})},
-                   Tensor {Shape {3}, ngraph::element::i64, std::vector<int64_t>({1, 2, 3})},
+                   Tensor {Shape {3}, ov::element::i64, std::vector<int64_t>({1, 2, 3})},
                    true,
                    1e-9,
-                   ngraph::op::MVNEpsMode::OUTSIDE_SQRT,
+                   op::MVNEpsMode::OUTSIDE_SQRT,
                    Tensor {{1, 3, 3, 3},
-                           ngraph::element::f32,
+                           ov::element::f32,
                            std::vector<float> {-1.5491934, -1.161895, -0.7745967, -0.38729835, 0., 0.38729835, 0.7745967, 1.161895, 1.5491934,
                                                -1.5491934, -1.161895, -0.7745967, -0.38729835, 0., 0.38729835, 0.7745967, 1.161895, 1.5491934,
                                                -1.5491934, -1.161895, -0.7745967, -0.38729835, 0., 0.38729835, 0.7745967, 1.161895, 1.5491934}})),
diff --git a/docs/template_plugin/tests/functional/op_reference/not_equal.cpp b/docs/template_plugin/tests/functional/op_reference/not_equal.cpp
index e0292ecc67a..d341a23aec8 100644
--- a/docs/template_plugin/tests/functional/op_reference/not_equal.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/not_equal.cpp
@@ -4,15 +4,10 @@
 
 #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 "openvino/op/not_equal.hpp"
 #include "comparison.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using ComparisonTypes = ngraph::helpers::ComparisonTypes;
 
 
diff --git a/docs/template_plugin/tests/functional/op_reference/random_uniform.cpp b/docs/template_plugin/tests/functional/op_reference/random_uniform.cpp
index 2e454e4a145..0e82b44bdfa 100644
--- a/docs/template_plugin/tests/functional/op_reference/random_uniform.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/random_uniform.cpp
@@ -4,13 +4,10 @@
 
 #include <gtest/gtest.h>
 
-#include <vector>
-
 #include "base_reference_test.hpp"
-#include "ngraph/opsets/opset8.hpp"
-#include "ngraph/util.hpp"
+#include "openvino/opsets/opset8.hpp"
 
-using namespace ngraph;
+using namespace ov;
 
 namespace reference_tests {
 namespace {
@@ -19,7 +16,7 @@ struct RandomUniformParams {
     RandomUniformParams(const std::vector<int64_t>& paramOutShape,
                         const Tensor& paramMinValue,
                         const Tensor& paramMaxValue,
-                        ngraph::element::Type paramOutType,
+                        ov::element::Type paramOutType,
                         int64_t paramGlobalSeed,
                         int64_t paramOpSeed,
                         const Tensor& paramExpected,
@@ -35,7 +32,7 @@ struct RandomUniformParams {
     std::vector<int64_t> out_shape;
     Tensor min_val;
     Tensor max_val;
-    ngraph::element::Type out_type;
+    ov::element::Type out_type;
     int64_t global_seed;
     int64_t op_seed;
     Tensor expected;
@@ -64,14 +61,14 @@ private:
     static std::shared_ptr<Function> CreateFunction(const std::vector<int64_t>& out_shape,
                                                     const Tensor& min_val,
                                                     const Tensor& max_val,
-                                                    const ngraph::element::Type& out_type,
+                                                    const ov::element::Type& out_type,
                                                     int64_t global_seed,
                                                     int64_t op_seed) {
         const auto min_val_param = std::make_shared<opset8::Parameter>(min_val.type, min_val.shape);
         const auto max_val_param = std::make_shared<opset8::Parameter>(max_val.type, max_val.shape);
         auto out_shape_ = std::make_shared<opset8::Constant>(element::i64, Shape{out_shape.size()}, out_shape);
 
-        return std::make_shared<Function>(NodeVector{std::make_shared<opset8::RandomUniform>(out_shape_,
+        return std::make_shared<ov::Function>(NodeVector{std::make_shared<opset8::RandomUniform>(out_shape_,
                                                                                              min_val_param,
                                                                                              max_val_param,
                                                                                              out_type,
diff --git a/docs/template_plugin/tests/functional/op_reference/reduce_l1.cpp b/docs/template_plugin/tests/functional/op_reference/reduce_l1.cpp
index b26beac64f8..ae63eec5fb9 100644
--- a/docs/template_plugin/tests/functional/op_reference/reduce_l1.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/reduce_l1.cpp
@@ -4,15 +4,10 @@
 
 #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 "openvino/op/reduce_l1.hpp"
 #include "reduction.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using ReductionType = ngraph::helpers::ReductionType;
 
 namespace reference_tests {
@@ -25,7 +20,7 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
     std::vector<ReductionParams> params = {
         ReductionParams(ReductionType::L1, keep_dims, std::vector<int64_t>{2},
                         Tensor({3, 2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}),
-                        Tensor(reduce(Shape{3, 2, 2}, AxisSet{2}, keep_dims),
+                        Tensor(ngraph::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/docs/template_plugin/tests/functional/op_reference/reduce_l2.cpp b/docs/template_plugin/tests/functional/op_reference/reduce_l2.cpp
index 0cc977cf75a..0651cb7dc3a 100644
--- a/docs/template_plugin/tests/functional/op_reference/reduce_l2.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/reduce_l2.cpp
@@ -4,15 +4,10 @@
 
 #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 "openvino/op/reduce_l2.hpp"
 #include "reduction.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using ReductionType = ngraph::helpers::ReductionType;
 
 namespace reference_tests {
@@ -26,7 +21,7 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
     std::vector<ReductionParams> params = {
         ReductionParams(ReductionType::L2, keep_dims, std::vector<int64_t>{2},
                         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}),
-                        Tensor(reduce(Shape{3, 2, 2}, AxisSet{2}, keep_dims),
+                        Tensor(ngraph::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;
@@ -39,7 +34,7 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
     std::vector<ReductionParams> params = {
         ReductionParams(ReductionType::L2, keep_dims, std::vector<int64_t>{2},
                         Tensor({3, 2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}),
-                        Tensor(reduce(Shape{3, 2, 2}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{2, 5, 8, 11, 13, 16}))
+                        Tensor(ngraph::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/docs/template_plugin/tests/functional/op_reference/reduce_max.cpp b/docs/template_plugin/tests/functional/op_reference/reduce_max.cpp
index 6d3e519efa9..cbd740b921b 100644
--- a/docs/template_plugin/tests/functional/op_reference/reduce_max.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/reduce_max.cpp
@@ -4,15 +4,10 @@
 
 #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 "openvino/op/reduce_max.hpp"
 #include "reduction.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using ReductionType = ngraph::helpers::ReductionType;
 
 namespace reference_tests {
@@ -25,29 +20,30 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
     std::vector<ReductionParams> params = {
         ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{0, 1},
                         Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}),
-                        Tensor(reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{4})),
+                        Tensor(ngraph::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},
                         Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        Tensor(reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{5, 6})),
+                        Tensor(ngraph::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},
                         Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        Tensor(reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{2, 4, 6})),
+                        Tensor(ngraph::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},
                         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}),
-                        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})),
+                        Tensor(ngraph::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},
                         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}),
-                        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})),
+                        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})),
         ReductionParams(ReductionType::Max, keep_dims, std::vector<int64_t>{0, 1},
                         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}),
-                        Tensor(reduce(Shape{3, 3, 3}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{25, 26, 27})),
+                        Tensor(ngraph::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},
                         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}),
-                        Tensor(reduce(Shape{3, 3, 3}, AxisSet{0, 1, 2}, keep_dims), element::Type(IN_ET), std::vector<T>{27}))
+                        Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0, 1, 2}, keep_dims), element::Type(IN_ET), std::vector<T>{27}))
     };
     return params;
 }
diff --git a/docs/template_plugin/tests/functional/op_reference/reduce_mean.cpp b/docs/template_plugin/tests/functional/op_reference/reduce_mean.cpp
index b6f05c23c20..e326f47d29f 100644
--- a/docs/template_plugin/tests/functional/op_reference/reduce_mean.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/reduce_mean.cpp
@@ -4,15 +4,10 @@
 
 #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 "openvino/op/reduce_mean.hpp"
 #include "reduction.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using ReductionType = ngraph::helpers::ReductionType;
 
 namespace reference_tests {
@@ -26,13 +21,13 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
     std::vector<ReductionParams> params = {
         ReductionParams(ReductionType::Mean, keep_dims, std::vector<int64_t>{0, 1},
                         Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}),
-                        Tensor(reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{2.5})),
+                        Tensor(ngraph::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},
                         Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        Tensor(reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{3, 4})),
+                        Tensor(ngraph::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},
                         Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        Tensor(reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{1.5, 3.5, 5.5}))
+                        Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{1.5, 3.5, 5.5}))
     };
     return params;
 }
@@ -44,13 +39,13 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
     std::vector<ReductionParams> params = {
         ReductionParams(ReductionType::Mean, keep_dims, std::vector<int64_t>{0, 1},
                         Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}),
-                        Tensor(reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{2})),
+                        Tensor(ngraph::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},
                         Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        Tensor(reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{3, 4})),
+                        Tensor(ngraph::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},
                         Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        Tensor(reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 3, 5}))
+                        Tensor(ngraph::reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 3, 5}))
     };
     return params;
 }
diff --git a/docs/template_plugin/tests/functional/op_reference/reduce_min.cpp b/docs/template_plugin/tests/functional/op_reference/reduce_min.cpp
index ce5c8a2753b..654b9099fa0 100644
--- a/docs/template_plugin/tests/functional/op_reference/reduce_min.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/reduce_min.cpp
@@ -4,15 +4,10 @@
 
 #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 "openvino/op/reduce_min.hpp"
 #include "reduction.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using ReductionType = ngraph::helpers::ReductionType;
 
 namespace reference_tests {
@@ -25,29 +20,29 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
     std::vector<ReductionParams> params = {
         ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{0, 1},
                         Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}),
-                        Tensor(reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{1})),
+                        Tensor(ngraph::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},
                         Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        Tensor(reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 2})),
+                        Tensor(ngraph::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},
                         Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        Tensor(reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 3, 5})),
+                        Tensor(ngraph::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},
                         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}),
-                        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})),
+                        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})),
         ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{2},
                         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}),
-                        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})),
+                        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})),
         ReductionParams(ReductionType::Min, keep_dims, std::vector<int64_t>{0, 1},
                         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}),
-                        Tensor(reduce(Shape{3, 3, 3}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{1, 2, 3})),
+                        Tensor(ngraph::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},
                         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}),
-                        Tensor(reduce(Shape{3, 3, 3}, AxisSet{0, 1, 2}, keep_dims), element::Type(IN_ET), std::vector<T>{1}))
+                        Tensor(ngraph::reduce(Shape{3, 3, 3}, AxisSet{0, 1, 2}, keep_dims), element::Type(IN_ET), std::vector<T>{1}))
     };
     return params;
 }
diff --git a/docs/template_plugin/tests/functional/op_reference/reduce_prod.cpp b/docs/template_plugin/tests/functional/op_reference/reduce_prod.cpp
index 38f316d23dd..5343c549513 100644
--- a/docs/template_plugin/tests/functional/op_reference/reduce_prod.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/reduce_prod.cpp
@@ -4,15 +4,10 @@
 
 #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 "openvino/op/reduce_prod.hpp"
 #include "reduction.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using ReductionType = ngraph::helpers::ReductionType;
 
 namespace reference_tests {
@@ -24,17 +19,17 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
     std::vector<ReductionParams> params = {
         ReductionParams(ReductionType::Prod, keep_dims, std::vector<int64_t>{0, 1},
                         Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}),
-                        Tensor(reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{24})),
+                        Tensor(ngraph::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},
                         Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        Tensor(reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{15, 48})),
+                        Tensor(ngraph::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},
                         Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        Tensor(reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{2, 12, 30})),
+                        Tensor(ngraph::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},
                         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}),
-                        Tensor(reduce(Shape{3, 3, 3}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{1 * 10 * 19,
+                        Tensor(ngraph::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,
@@ -46,7 +41,7 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
         ReductionParams(ReductionType::Prod, keep_dims, std::vector<int64_t>{2},
                         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}),
-                        Tensor(reduce(Shape{3, 3, 3}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{1 * 2 * 3,
+                        Tensor(ngraph::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/docs/template_plugin/tests/functional/op_reference/reduce_sum.cpp b/docs/template_plugin/tests/functional/op_reference/reduce_sum.cpp
index 8498280ca07..13cfc468ce4 100644
--- a/docs/template_plugin/tests/functional/op_reference/reduce_sum.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/reduce_sum.cpp
@@ -4,15 +4,10 @@
 
 #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 "openvino/op/reduce_sum.hpp"
 #include "reduction.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using ReductionType = ngraph::helpers::ReductionType;
 
 static std::mt19937_64 random_generator;
@@ -36,17 +31,17 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
     std::vector<ReductionParams> params = {
         ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0, 1},
                         Tensor({2, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4}),
-                        Tensor(reduce(Shape{2, 2}, AxisSet{0, 1}, keep_dims), element::Type(IN_ET), std::vector<T>{10})),
+                        Tensor(ngraph::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},
                         Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        Tensor(reduce(Shape{3, 2}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{9, 12})),
+                        Tensor(ngraph::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},
                         Tensor({3, 2}, element::Type(IN_ET), std::vector<T>{1, 2, 3, 4, 5, 6}),
-                        Tensor(reduce(Shape{3, 2}, AxisSet{1}, keep_dims), element::Type(IN_ET), std::vector<T>{3, 7, 11})),
+                        Tensor(ngraph::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},
                         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}),
-                        Tensor(reduce(Shape{3, 3, 3}, AxisSet{0}, keep_dims), element::Type(IN_ET), std::vector<T>{1 + 10 + 19,
+                        Tensor(ngraph::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,
@@ -58,7 +53,7 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
         ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{2},
                         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}),
-                        Tensor(reduce(Shape{3, 3, 3}, AxisSet{2}, keep_dims), element::Type(IN_ET), std::vector<T>{1 + 2 + 3,
+                        Tensor(ngraph::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,
@@ -70,18 +65,19 @@ std::vector<ReductionParams> generateReductionParams(const bool keep_dims) {
         ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0, 1},
                         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}),
-                        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,
+                        Tensor(ngraph::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},
                         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}),
-                        Tensor(reduce(Shape{3, 3, 3}, AxisSet{0, 1, 2}, keep_dims), element::Type(IN_ET),
+                        Tensor(ngraph::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},
                         Tensor({3, 3, 3, 3, 3}, element::Type(IN_ET), std::vector<T>(std::pow(3, 5), 1)),
-                        Tensor(reduce(Shape{3, 3, 3, 3, 3}, AxisSet{0, 1, 2, 3, 4}, keep_dims), element::Type(IN_ET), std::vector<T>{243}))
+                        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}))
     };
     return params;
 }
@@ -92,12 +88,12 @@ std::vector<ReductionParams> generateReductionParamsFloat(const bool keep_dims)
     std::vector<ReductionParams> params = {
         ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0},
                         Tensor({1000000}, element::f32, in),
-                        Tensor(reduce(Shape{1000000}, AxisSet{0}, keep_dims), element::f32, std::vector<float>{res})),
+                        Tensor(ngraph::reduce(Shape{1000000}, AxisSet{0}, keep_dims), element::f32, std::vector<float>{res})),
         ReductionParams(ReductionType::Sum, keep_dims, std::vector<int64_t>{0},
                         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}),
-                        Tensor(reduce(Shape{20}, AxisSet{0}, keep_dims), element::f32, std::vector<float>{10000010.2f}))
+                        Tensor(ngraph::reduce(Shape{20}, AxisSet{0}, keep_dims), element::f32, std::vector<float>{10000010.2f}))
     };
     return params;
 }
diff --git a/docs/template_plugin/tests/functional/op_reference/reduction.hpp b/docs/template_plugin/tests/functional/op_reference/reduction.hpp
index 951711511b8..492cb520593 100644
--- a/docs/template_plugin/tests/functional/op_reference/reduction.hpp
+++ b/docs/template_plugin/tests/functional/op_reference/reduction.hpp
@@ -4,14 +4,12 @@
 
 #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 "shared_test_classes/base/layer_test_utils.hpp"
 #include "ngraph_functions/builders.hpp"
+#include "ngraph/shape_util.hpp"
+
+using namespace ov;
 
 namespace reference_tests {
 namespace ReductionOpsRefTestDefinitions {
@@ -51,13 +49,13 @@ public:
     }
 
 private:
-    static std::shared_ptr<ngraph::Function> CreateFunction(const ReductionParams& params) {
-        const auto data = std::make_shared<ngraph::op::Parameter>(params.data.type, params.data.shape);
-        const auto axes = std::make_shared<ngraph::op::Constant>(ngraph::element::i64,
-                                                                 ngraph::Shape{params.reductionAxes.size()},
-                                                                 params.reductionAxes);
+    static std::shared_ptr<ov::Function> CreateFunction(const ReductionParams& params) {
+        const auto data = std::make_shared<op::v0::Parameter>(params.data.type, params.data.shape);
+        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);
-        return std::make_shared<ngraph::Function>(reduction, ngraph::ParameterVector{data});
+        return std::make_shared<ov::Function>(reduction, ov::ParameterVector{data});
     }
 };
 } // namespace ReductionOpsRefTestDefinitions
diff --git a/docs/template_plugin/tests/functional/op_reference/reverse_sequence.cpp b/docs/template_plugin/tests/functional/op_reference/reverse_sequence.cpp
index 26e2289a528..670e521247e 100644
--- a/docs/template_plugin/tests/functional/op_reference/reverse_sequence.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/reverse_sequence.cpp
@@ -4,18 +4,11 @@
 
 #include <gtest/gtest.h>
 
-#include <ie_core.hpp>
-#include <ie_ngraph_utils.hpp>
-#include <limits>
-#include <algorithm>
-#include <ngraph/ngraph.hpp>
-#include <shared_test_classes/base/layer_test_utils.hpp>
-
+#include "openvino/op/reverse_sequence.hpp"
 #include "base_reference_test.hpp"
 
 using namespace reference_tests;
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 
 namespace {
 struct ReverseSequenceParams {
@@ -50,10 +43,10 @@ public:
 
 private:
     static std::shared_ptr<Function> CreateFunction(const ReverseSequenceParams& params) {
-        const auto data = std::make_shared<op::Parameter>(params.mDataTensor.type, params.mDataTensor.shape);
-        const auto seqLengths = std::make_shared<op::Parameter>(params.mSeqLengthsTensor.type, params.mSeqLengthsTensor.shape);
-        const auto reverseSequence = std::make_shared<op::ReverseSequence>(data, seqLengths, params.mBatchAxis, params.mSeqAxis);
-        return std::make_shared<Function>(NodeVector {reverseSequence}, ParameterVector {data, seqLengths});
+        const auto data = std::make_shared<op::v0::Parameter>(params.mDataTensor.type, params.mDataTensor.shape);
+        const auto seqLengths = std::make_shared<op::v0::Parameter>(params.mSeqLengthsTensor.type, params.mSeqLengthsTensor.shape);
+        const auto reverseSequence = std::make_shared<op::v0::ReverseSequence>(data, seqLengths, params.mBatchAxis, params.mSeqAxis);
+        return std::make_shared<ov::Function>(NodeVector {reverseSequence}, ParameterVector {data, seqLengths});
     }
 };
 
diff --git a/docs/template_plugin/tests/functional/op_reference/roi_pooling.cpp b/docs/template_plugin/tests/functional/op_reference/roi_pooling.cpp
index cf92b51fdfb..be0586e4013 100644
--- a/docs/template_plugin/tests/functional/op_reference/roi_pooling.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/roi_pooling.cpp
@@ -4,26 +4,21 @@
 
 #include <gtest/gtest.h>
 
-#include <ie_core.hpp>
-#include <ie_ngraph_utils.hpp>
-#include <ngraph/ngraph.hpp>
-#include <tuple>
-
+#include "openvino/op/roi_pooling.hpp"
 #include "base_reference_test.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using namespace reference_tests;
 
 struct ROIPoolingParams {
     template <class T>
     ROIPoolingParams(const size_t iH, const size_t iW, const size_t ch, const size_t rois,
                      const size_t oH, const size_t oW, const float sS, const std::string mode,
-                     const ngraph::element::Type& type, const std::vector<T>& inputValues,
+                     const ov::element::Type& type, const std::vector<T>& inputValues,
                      const std::vector<T>& proposalValues, const std::vector<T>& outputValues)
             : inputH(iH), inputW(iW), channelCount(ch), roiCount(rois), outputH(oH), outputW(oW), spatialScale(sS),
-              poolingMode(mode), dataType(type), featureMap(CreateBlob(type, inputValues)),
-              proposal(CreateBlob(type, proposalValues)), refData(CreateBlob(type, outputValues)) {}
+              poolingMode(mode), dataType(type), featureMap(CreateTensor(type, inputValues)),
+              proposal(CreateTensor(type, proposalValues)), refData(CreateTensor(type, outputValues)) {}
     size_t inputH;
     size_t inputW;
     size_t channelCount;
@@ -32,7 +27,7 @@ struct ROIPoolingParams {
     size_t outputW;
     float spatialScale;
     std::string poolingMode;
-    ngraph::element::Type dataType;
+    ov::element::Type dataType;
     ov::runtime::Tensor featureMap;
     ov::runtime::Tensor proposal;
     ov::runtime::Tensor refData;
@@ -83,16 +78,16 @@ public:
 private:
     static std::shared_ptr<Function> CreateFunction(const size_t i_h, const size_t i_w, const size_t ch, const size_t roi_count,
                                                     const size_t o_h, const size_t o_w, const float spat_scale, const std::string mode,
-                                                    const ngraph::element::Type& type) {
+                                                    const ov::element::Type& type) {
         Shape feat_map_shape{1, ch, i_h, i_w};
         Shape rois_shape{roi_count, 5};
         Shape pooled_shape{o_h, o_w};
         Shape output_shape{roi_count, ch, o_h, o_w};
 
-        const auto feat_map = std::make_shared<op::Parameter>(type, feat_map_shape);
-        const auto rois = std::make_shared<op::Parameter>(type, rois_shape);
+        const auto feat_map = std::make_shared<op::v0::Parameter>(type, feat_map_shape);
+        const auto rois = std::make_shared<op::v0::Parameter>(type, rois_shape);
         const auto roi_pooling = std::make_shared<op::v0::ROIPooling>(feat_map, rois, pooled_shape, spat_scale, mode);
-        return std::make_shared<Function>(roi_pooling, ParameterVector{feat_map, rois});
+        return std::make_shared<ov::Function>(roi_pooling, ParameterVector{feat_map, rois});
     }
 };
 
diff --git a/docs/template_plugin/tests/functional/op_reference/scatter_elements_update.cpp b/docs/template_plugin/tests/functional/op_reference/scatter_elements_update.cpp
index 3d844bfcf6d..b72ea5c720d 100644
--- a/docs/template_plugin/tests/functional/op_reference/scatter_elements_update.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/scatter_elements_update.cpp
@@ -4,17 +4,11 @@
 
 #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 <tuple>
-
+#include "openvino/op/scatter_elements_update.hpp"
 #include "base_reference_test.hpp"
 
 using namespace reference_tests;
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 
 namespace {
 struct ScatterElementsUpdateParams {
@@ -63,12 +57,12 @@ public:
     }
 private:
     static std::shared_ptr<Function> CreateFunction(const ScatterElementsUpdateParams& params) {
-        const auto A = std::make_shared<op::Parameter>(params.input.type, params.input.shape);
-        const auto B = std::make_shared<op::Parameter>(params.indices.type, params.indices.shape);
-        const auto C = std::make_shared<op::Parameter>(params.updates.type, params.updates.shape);
-        const auto D = std::make_shared<op::Parameter>(params.axis.type, params.axis.shape);
-        auto scatterElts = std::make_shared<op::ScatterElementsUpdate>(A, B, C, D);
-        return std::make_shared<Function>(NodeVector{scatterElts}, ParameterVector{A, B, C, D});
+        const auto A = std::make_shared<op::v0::Parameter>(params.input.type, params.input.shape);
+        const auto B = std::make_shared<op::v0::Parameter>(params.indices.type, params.indices.shape);
+        const auto C = std::make_shared<op::v0::Parameter>(params.updates.type, params.updates.shape);
+        const auto D = std::make_shared<op::v0::Parameter>(params.axis.type, params.axis.shape);
+        auto scatterElts = std::make_shared<op::v3::ScatterElementsUpdate>(A, B, C, D);
+        return std::make_shared<ov::Function>(NodeVector{scatterElts}, ParameterVector{A, B, C, D});
     }
 };
 
diff --git a/docs/template_plugin/tests/functional/op_reference/select.cpp b/docs/template_plugin/tests/functional/op_reference/select.cpp
index 1f7070df7ca..5df33928f8c 100644
--- a/docs/template_plugin/tests/functional/op_reference/select.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/select.cpp
@@ -4,17 +4,11 @@
 
 #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 <tuple>
-
+#include "openvino/op/select.hpp"
 #include "base_reference_test.hpp"
 
 using namespace reference_tests;
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 
 struct SelectParams {
     template <class IT, class OT>
@@ -24,12 +18,12 @@ struct SelectParams {
         : data_type(data_type),
           broadcast(broadcast),
           select_input_pshape(select_input_pshape),
-          select_input(CreateBlob(element::boolean, select_input)),
+          select_input(CreateTensor(element::boolean, select_input)),
           if_input_pshape(if_input_pshape),
-          if_input(CreateBlob(data_type, if_input)),
+          if_input(CreateTensor(data_type, if_input)),
           else_input_pshape(else_input_pshape),
-          else_input(CreateBlob(data_type, else_input)),
-          expected_output(CreateBlob(data_type, expected_output)) {}
+          else_input(CreateTensor(data_type, else_input)),
+          expected_output(CreateTensor(data_type, expected_output)) {}
 
     element::Type data_type;
     op::AutoBroadcastSpec broadcast;
@@ -64,10 +58,10 @@ public:
 private:
     static std::shared_ptr<Function> CreateFunction(const element::Type& data_type, const op::AutoBroadcastSpec& broadcast,
                                                     const PartialShape& select_pshape, const PartialShape& if_pshape, const PartialShape& else_pshape) {
-        auto A = std::make_shared<op::Parameter>(element::boolean, select_pshape);
-        auto B = std::make_shared<op::Parameter>(data_type, if_pshape);
-        auto C = std::make_shared<op::Parameter>(data_type, else_pshape);
-        return std::make_shared<Function>(std::make_shared<op::v1::Select>(A, B, C, broadcast), ParameterVector {A, B, C});
+        auto A = std::make_shared<op::v0::Parameter>(element::boolean, select_pshape);
+        auto B = std::make_shared<op::v0::Parameter>(data_type, if_pshape);
+        auto C = std::make_shared<op::v0::Parameter>(data_type, else_pshape);
+        return std::make_shared<ov::Function>(std::make_shared<op::v1::Select>(A, B, C, broadcast), ParameterVector {A, B, C});
     }
 };
 
diff --git a/docs/template_plugin/tests/functional/op_reference/sign.cpp b/docs/template_plugin/tests/functional/op_reference/sign.cpp
index 38d01c1e06e..674ca44bff6 100644
--- a/docs/template_plugin/tests/functional/op_reference/sign.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/sign.cpp
@@ -4,23 +4,17 @@
 
 #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 <tuple>
-
+#include "openvino/op/sign.hpp"
 #include "base_reference_test.hpp"
 
 using namespace reference_tests;
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 
 struct SignParams {
     template <class IT, class OT>
     SignParams(const PartialShape& shape, const element::Type& iType, const element::Type& oType, const std::vector<IT>& iValues,
                   const std::vector<OT>& oValues)
-        : pshape(shape), inType(iType), outType(oType), inputData(CreateBlob(iType, iValues)), refData(CreateBlob(oType, oValues)) {}
+        : pshape(shape), inType(iType), outType(oType), inputData(CreateTensor(iType, iValues)), refData(CreateTensor(oType, oValues)) {}
     PartialShape pshape;
     element::Type inType;
     element::Type outType;
@@ -47,9 +41,9 @@ public:
 
 private:
     static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape, const element::Type& input_type) {
-        const auto in = std::make_shared<op::Parameter>(input_type, input_shape);
-        const auto sign = std::make_shared<op::Sign>(in);
-        return std::make_shared<Function>(NodeVector {sign}, ParameterVector {in});
+        const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
+        const auto sign = std::make_shared<op::v0::Sign>(in);
+        return std::make_shared<ov::Function>(NodeVector {sign}, ParameterVector {in});
     }
 };
 
diff --git a/docs/template_plugin/tests/functional/op_reference/sin.cpp b/docs/template_plugin/tests/functional/op_reference/sin.cpp
index 498fe820615..1616be009f1 100644
--- a/docs/template_plugin/tests/functional/op_reference/sin.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/sin.cpp
@@ -4,15 +4,10 @@
 
 #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 "openvino/op/sin.hpp"
 #include "base_reference_test.hpp"
 
-using namespace ngraph;
+using namespace ov;
 
 namespace reference_tests {
 namespace {
@@ -45,9 +40,9 @@ public:
 
 private:
     static std::shared_ptr<Function> CreateFunction(const Shape& shape, const element::Type& type) {
-        const auto in = std::make_shared<op::Parameter>(type, shape);
-        const auto Sin = std::make_shared<op::Sin>(in);
-        return std::make_shared<Function>(NodeVector {Sin}, ParameterVector {in});
+        const auto in = std::make_shared<op::v0::Parameter>(type, shape);
+        const auto Sin = std::make_shared<op::v0::Sin>(in);
+        return std::make_shared<ov::Function>(NodeVector {Sin}, ParameterVector {in});
     }
 };
 
diff --git a/docs/template_plugin/tests/functional/op_reference/sinh.cpp b/docs/template_plugin/tests/functional/op_reference/sinh.cpp
index 4ebc78e3a17..324adb5a99c 100644
--- a/docs/template_plugin/tests/functional/op_reference/sinh.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/sinh.cpp
@@ -4,15 +4,10 @@
 
 #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 "openvino/op/sinh.hpp"
 #include "base_reference_test.hpp"
 
-using namespace ngraph;
+using namespace ov;
 
 namespace reference_tests {
 namespace {
@@ -45,9 +40,9 @@ public:
 
 private:
     static std::shared_ptr<Function> CreateFunction(const Shape& shape, const element::Type& type) {
-        const auto in = std::make_shared<op::Parameter>(type, shape);
-        const auto Sinh = std::make_shared<op::Sinh>(in);
-        return std::make_shared<Function>(NodeVector {Sinh}, ParameterVector {in});
+        const auto in = std::make_shared<op::v0::Parameter>(type, shape);
+        const auto Sinh = std::make_shared<op::v0::Sinh>(in);
+        return std::make_shared<ov::Function>(NodeVector {Sinh}, ParameterVector {in});
     }
 };
 
diff --git a/docs/template_plugin/tests/functional/op_reference/tan.cpp b/docs/template_plugin/tests/functional/op_reference/tan.cpp
index 56118b04ea2..59de9a88a78 100644
--- a/docs/template_plugin/tests/functional/op_reference/tan.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/tan.cpp
@@ -4,27 +4,21 @@
 
 #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 <tuple>
-
+#include "openvino/op/tan.hpp"
 #include "base_reference_test.hpp"
 
-using namespace ngraph;
-using namespace InferenceEngine;
+using namespace ov;
 using namespace reference_tests;
 
 namespace {
 struct TanParams {
     template <class IT>
-    TanParams(const ngraph::PartialShape& shape, const ngraph::element::Type& iType, const std::vector<IT>& iValues,
+    TanParams(const ov::PartialShape& shape, const ov::element::Type& iType, const std::vector<IT>& iValues,
               const std::vector<IT>& oValues)
-        :pshape(shape), inType(iType), outType(iType), inputData(CreateBlob(iType, iValues)), refData(CreateBlob(iType, oValues)) {}
-    ngraph::PartialShape pshape;
-    ngraph::element::Type inType;
-    ngraph::element::Type outType;
+        :pshape(shape), inType(iType), outType(iType), inputData(CreateTensor(iType, iValues)), refData(CreateTensor(iType, oValues)) {}
+    ov::PartialShape pshape;
+    ov::element::Type inType;
+    ov::element::Type outType;
     ov::runtime::Tensor inputData;
     ov::runtime::Tensor refData;
 };
@@ -48,9 +42,9 @@ public:
 
 private:
     static std::shared_ptr<Function> CreateFunction(const PartialShape& input_shape, const element::Type& input_type) {
-        const auto in = std::make_shared<op::Parameter>(input_type, input_shape);
-        const auto tan = std::make_shared<op::Tan>(in);
-        return std::make_shared<Function>(tan, ParameterVector {in});
+        const auto in = std::make_shared<op::v0::Parameter>(input_type, input_shape);
+        const auto tan = std::make_shared<op::v0::Tan>(in);
+        return std::make_shared<ov::Function>(tan, ParameterVector {in});
     }
 };
 
@@ -60,19 +54,19 @@ TEST_P(ReferenceTanLayerTest, CompareWithHardcodedRefs) {
 
 std::vector<TanParams> generateTanCombinedParams() {
     std::vector<TanParams> combinedParams {
-        TanParams(ngraph::PartialShape {5}, ngraph::element::i32, std::vector<int32_t> {-2, -1, 0, 1, 2},
+        TanParams(ov::PartialShape {5}, ov::element::i32, std::vector<int32_t> {-2, -1, 0, 1, 2},
                   std::vector<int32_t> {2, -2, 0, 2, -2}),
-        TanParams(ngraph::PartialShape {5}, ngraph::element::i64, std::vector<int64_t> {-2, -1, 0, 1, 2},
+        TanParams(ov::PartialShape {5}, ov::element::i64, std::vector<int64_t> {-2, -1, 0, 1, 2},
                   std::vector<int64_t> {2, -2, 0, 2, -2}),
-        TanParams(ngraph::PartialShape {5}, ngraph::element::u32, std::vector<uint32_t> {1, 2, 3, 4, 5},
+        TanParams(ov::PartialShape {5}, ov::element::u32, std::vector<uint32_t> {1, 2, 3, 4, 5},
                   std::vector<uint32_t> {2, 0xFFFFFFFF - 1, 0, 1, 0xFFFFFFFF - 2}),
-        TanParams(ngraph::PartialShape {5}, ngraph::element::u64, std::vector<uint64_t> {1, 2, 3, 4, 5},
+        TanParams(ov::PartialShape {5}, ov::element::u64, std::vector<uint64_t> {1, 2, 3, 4, 5},
                   std::vector<uint64_t> {2, 0xFFFFFFFFFFFFFFFF - 1, 0, 1, 0xFFFFFFFFFFFFFFFF - 2}),
-        TanParams(ngraph::PartialShape {11}, ngraph::element::f32, std::vector<float> {0.f, 0.25f,
+        TanParams(ov::PartialShape {11}, ov::element::f32, std::vector<float> {0.f, 0.25f,
                       -0.25f, 0.5f, -0.5f, 1.f, -1.f, 2.f, -2.f, 4.f, -4.f},
                   std::vector<float> {0.00000000f, 0.25534192f, -0.25534192f, 0.54630249f, -0.54630249f,
                        1.55740772f, -1.55740772f, -2.18503986f, 2.18503986f, 1.15782128f, -1.15782128f}),
-        TanParams(ngraph::PartialShape {11}, ngraph::element::f16, std::vector<float16> {0.f, 0.25f,
+        TanParams(ov::PartialShape {11}, ov::element::f16, std::vector<float16> {0.f, 0.25f,
                       -0.25f, 0.5f, -0.5f, 1.f, -1.f, 2.f, -2.f, 4.f, -4.f},
                   std::vector<float16> {0.00000000f, 0.25534192f, -0.25534192f, 0.54630249f, -0.54630249f,
                        1.55740772f, -1.55740772f, -2.18503986f, 2.18503986f, 1.15782128f, -1.15782128f})
diff --git a/docs/template_plugin/tests/functional/op_reference/tanh.cpp b/docs/template_plugin/tests/functional/op_reference/tanh.cpp
index 75d25fa198e..bd7a3480d60 100644
--- a/docs/template_plugin/tests/functional/op_reference/tanh.cpp
+++ b/docs/template_plugin/tests/functional/op_reference/tanh.cpp
@@ -4,15 +4,10 @@
 
 #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 "openvino/op/tanh.hpp"
 #include "base_reference_test.hpp"
 
-using namespace ngraph;
+using namespace ov;
 
 namespace reference_tests {
 namespace {
@@ -45,9 +40,9 @@ public:
 
 private:
     static std::shared_ptr<Function> CreateFunction(const Shape& shape, const element::Type& type) {
-        const auto in = std::make_shared<op::Parameter>(type, shape);
-        const auto Tanh = std::make_shared<op::Tanh>(in);
-        return std::make_shared<Function>(NodeVector {Tanh}, ParameterVector {in});
+        const auto in = std::make_shared<op::v0::Parameter>(type, shape);
+        const auto Tanh = std::make_shared<op::v0::Tanh>(in);
+        return std::make_shared<ov::Function>(NodeVector {Tanh}, ParameterVector {in});
     }
 };
 
diff --git a/docs/template_plugin/tests/functional/shared_tests_instances/behavior/caching/caching_tests.cpp b/docs/template_plugin/tests/functional/shared_tests_instances/behavior/caching/caching_tests.cpp
index aa0fae40e2c..0861c4fc5bd 100644
--- a/docs/template_plugin/tests/functional/shared_tests_instances/behavior/caching/caching_tests.cpp
+++ b/docs/template_plugin/tests/functional/shared_tests_instances/behavior/caching/caching_tests.cpp
@@ -7,8 +7,8 @@
 using namespace LayerTestsDefinitions;
 
 namespace {
-    static const std::vector<ngraph::element::Type> precisionsTemplate = {
-            ngraph::element::f32,
+    static const std::vector<ov::element::Type> precisionsTemplate = {
+            ov::element::f32,
     };
 
     static const std::vector<std::size_t> batchSizesTemplate = {
diff --git a/docs/template_plugin/tests/functional/subgraph_reference/preprocess.cpp b/docs/template_plugin/tests/functional/subgraph_reference/preprocess.cpp
index fcc6107fb31..f86107ef428 100644
--- a/docs/template_plugin/tests/functional/subgraph_reference/preprocess.cpp
+++ b/docs/template_plugin/tests/functional/subgraph_reference/preprocess.cpp
@@ -59,7 +59,7 @@ static std::shared_ptr<Function> create_simple_function(element::Type type, cons
     data1->get_output_tensor(0).set_names({"tensor_input1"});
     auto res = std::make_shared<op::v0::Result>(data1);
     res->set_friendly_name("Result");
-    return std::make_shared<Function>(ResultVector{res}, ParameterVector{data1});
+    return std::make_shared<ov::Function>(ResultVector{res}, ParameterVector{data1});
 }
 
 static std::shared_ptr<Function> create_2inputs(element::Type type, const PartialShape& shape) {
@@ -73,7 +73,7 @@ static std::shared_ptr<Function> create_2inputs(element::Type type, const Partia
     res1->set_friendly_name("Result1");
     auto res2 = std::make_shared<op::v0::Result>(data2);
     res2->set_friendly_name("Result2");
-    return std::make_shared<Function>(ResultVector{res1, res2}, ParameterVector{data1, data2});
+    return std::make_shared<ov::Function>(ResultVector{res1, res2}, ParameterVector{data1, data2});
 }
 
 static RefPreprocessParams simple_mean_scale() {