Remove deprecated functions

src/common/transformations/tests/common_optimizations/nop_elimination.cpp

@@ -354,7 +354,7 @@ TEST(nop_elimination, reshape_elimination_v1_check_consumer_count) {
 TEST(nop_elimination, concat_elimination_single_node) {
     int64_t a = 0;
     auto A = make_shared<op::v0::Parameter>(element::f32, Shape{2, 3});
-    auto f = make_shared<ov::Model>(make_shared<op::v0::Concat>(NodeVector{A}, a), ParameterVector{A});
+    auto f = make_shared<ov::Model>(make_shared<op::v0::Concat>(OutputVector{A}, a), ParameterVector{A});
 
     pass::Manager pass_manager;
     pass_manager.register_pass<ov::pass::Validate>();

src/core/dev_api/openvino/runtime/itensor.hpp

@@ -10,7 +10,6 @@
 #include "openvino/core/core_visibility.hpp"
 #include "openvino/core/shape.hpp"
 #include "openvino/core/type/element_type.hpp"
-#include "openvino/runtime/allocator.hpp"
 
 namespace ov {
 

src/core/include/openvino/core/model.hpp

@@ -53,10 +53,6 @@ class OPENVINO_API Model : public std::enable_shared_from_this<Model> {
 public:
     OPENVINO_RTTI_BASE("Model")
 
-    OPENVINO_DEPRECATED("This constructor is deprecated and will be remove in 2026.0. Use Model(const "
-                        "ov::OutputVector&, const ov::ParameterVector&, const std::string&) instead.")
-    Model(const ov::NodeVector& results, const ov::ParameterVector& parameters, const std::string& name = "");
-
     Model(const ov::OutputVector& results, const ov::ParameterVector& parameters, const std::string& name = "");
 
     Model(const std::shared_ptr<ov::Node>& result, const ov::ParameterVector& parameters, const std::string& name = "");

src/core/include/openvino/runtime/allocator.hpp

@@ -135,17 +135,6 @@ class OPENVINO_API Allocator {
             bool> = true>
     Allocator(A&& a) : _impl{std::make_shared<Impl<typename std::decay_t<A>>>(std::forward<A>(a))} {}
 
-    template <typename A,
-              typename std::enable_if_t<!std::is_same_v<typename std::decay_t<A>, Allocator> &&
-                                            !std::is_abstract_v<typename std::decay_t<A>> &&
-                                            !std::is_convertible_v<typename std::decay_t<A>, std::shared_ptr<Base>> &&
-                                            !has_noexcept_deallocate_v<A>,
-                                        bool> = true>
-    OPENVINO_DEPRECATED("Please annotate your allocator's deallocate method with noexcept. This method will be "
-                        "removed in 2026.0.0 release")
-    Allocator(A&& a)
-        : _impl{std::make_shared<Impl<typename std::decay_t<A>>>(std::forward<A>(a))} {}
-
     /**
      * @brief Allocates memory
      *

src/core/src/model.cpp

@@ -133,9 +133,6 @@ ov::Model::Model(const ResultVector& results, const ov::ParameterVector& paramet
 ov::Model::Model(const OutputVector& results, const ov::ParameterVector& parameters, const std::string& name)
     : Model(as_result_vector(results), parameters, name) {}
 
-ov::Model::Model(const NodeVector& results, const ov::ParameterVector& parameters, const std::string& name)
-    : Model(as_output_vector(results), parameters, name) {}
-
 ov::Model::Model(const std::shared_ptr<Node>& result, const ov::ParameterVector& parameters, const std::string& name)
     : Model(verify_node(result)->outputs(), parameters, name) {}
 

src/core/src/op/util/variable_value.cpp

@@ -8,7 +8,6 @@
 
 #include "openvino/core/shape.hpp"
 #include "openvino/core/shape_util.hpp"
-#include "openvino/runtime/allocator.hpp"
 #include "openvino/runtime/itensor.hpp"
 #include "openvino/runtime/tensor.hpp"
 

src/core/src/runtime/itensor.cpp

@@ -10,7 +10,6 @@
 #include "openvino/core/except.hpp"
 #include "openvino/core/memory_util.hpp"
 #include "openvino/core/shape_util.hpp"
-#include "openvino/runtime/allocator.hpp"
 #include "openvino/runtime/iremote_tensor.hpp"
 #include "openvino/runtime/make_tensor.hpp"
 #include "openvino/runtime/properties.hpp"

src/inference/dev_api/openvino/runtime/make_tensor.hpp

@@ -12,6 +12,7 @@
 #include "openvino/runtime/common.hpp"
 #include "openvino/runtime/itensor.hpp"
 #include "openvino/runtime/so_ptr.hpp"
+#include "openvino/runtime/allocator.hpp"
 
 namespace ov {
 

src/plugins/intel_cpu/tests/unit/transformations/arm/deconv_1d_decomposition.cpp

@@ -210,7 +210,7 @@ class DeconvDecomposition1DTest : public TransformationTestsF, public ::testing:
         auto output_3d_shape = ov::op::util::make_try_fold<ov::op::v8::Slice>(conv_shape, zero_1d, three_1d, one_const);
         auto output_3d = std::make_shared<ov::op::v1::Reshape>(conv, output_3d_shape, false);
 
-        return std::make_shared<ov::Model>(ov::NodeVector{output_3d}, ov::ParameterVector{input_e});
+        return std::make_shared<ov::Model>(ov::OutputVector{output_3d}, ov::ParameterVector{input_e});
     }
 
 protected:
@@ -261,7 +261,7 @@ class DeconvDecomposition1DTest : public TransformationTestsF, public ::testing:
                                                                            p.pad_type);
         }
 
-        model = std::make_shared<ov::Model>(ov::NodeVector{deconv}, ov::ParameterVector{input});
+        model = std::make_shared<ov::Model>(ov::OutputVector{deconv}, ov::ParameterVector{input});
 
         if (p.expect_transformation && rank == 3) {
             model_ref = buildExpectedModel(p);

src/plugins/intel_gpu/tests/common/subgraphs_builders.hpp

@@ -55,7 +55,7 @@ inline std::shared_ptr<ov::Model> makeLBRGRUSequence(ov::element::Type_t model_t
     Y_out->set_friendly_name("Y_out");
     Ho->set_friendly_name("Ho");
 
-    auto fn_ptr = std::make_shared<ov::Model>(ov::NodeVector{Y_out, Ho}, ov::ParameterVector{X, Y});
+    auto fn_ptr = std::make_shared<ov::Model>(ov::OutputVector{Y_out, Ho}, ov::ParameterVector{X, Y});
     fn_ptr->set_friendly_name("GRUSequence");
     return fn_ptr;
 }

src/plugins/intel_gpu/tests/functional/subgraph_tests/dynamic/transpose_matmul_fusion.cpp

@@ -38,7 +38,7 @@ class TransposeMatmulFuseTest : public ::testing::Test, public testing::WithPara
 
         auto matmul = std::make_shared<ov::op::v0::MatMul>(transpose_a, input_b, false, false);
 
-        auto model = std::make_shared<ov::Model>(ov::NodeVector{matmul}, ov::ParameterVector{input_a, input_b});
+        auto model = std::make_shared<ov::Model>(ov::OutputVector{matmul}, ov::ParameterVector{input_a, input_b});
         return model;
     }
 
@@ -125,7 +125,7 @@ class TransposeMatmulTransposeFuse3DTest : public ::testing::Test, public testin
         auto transpose_order_c = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{target_transpose_order_c.size()}, target_transpose_order_c);
         auto transpose_c = std::make_shared<ov::op::v1::Transpose>(matmul, transpose_order_c);
 
-        auto model = std::make_shared<ov::Model>(ov::NodeVector{transpose_c}, ov::ParameterVector{input_a, input_b});
+        auto model = std::make_shared<ov::Model>(ov::OutputVector{transpose_c}, ov::ParameterVector{input_a, input_b});
         return model;
     }
 

src/plugins/intel_gpu/tests/unit/transformations/disable_fp16_compression_rms_test.cpp

@@ -47,7 +47,7 @@ static std::shared_ptr<ov::Model> create_model_to_match() {
     auto rms_m = std::make_shared<ov::op::internal::RMS>(add_1_m, rms_const_2, 1e-5);
     rms_m->set_friendly_name(name_rms_2);
 
-    return std::make_shared<ov::Model>(ov::NodeVector{rms_m}, ov::ParameterVector{input1, input2, input3});
+    return std::make_shared<ov::Model>(ov::OutputVector{rms_m}, ov::ParameterVector{input1, input2, input3});
 }
 
 // This model has a similar structure but doesn't match the specific pattern.
@@ -64,7 +64,7 @@ static std::shared_ptr<ov::Model> create_model_not_to_match() {
     auto rms_2 = std::make_shared<ov::op::internal::RMS>(some_other_op, rms_const_2, 1e-5);
     rms_2->set_friendly_name(name_rms_2);
 
-    return std::make_shared<ov::Model>(ov::NodeVector{rms_2}, ov::ParameterVector{input1});
+    return std::make_shared<ov::Model>(ov::OutputVector{rms_2}, ov::ParameterVector{input1});
 }
 
 static void run_test(std::shared_ptr<ov::Model> model,

src/plugins/intel_gpu/tests/unit/transformations/transpose_matmul_fusion_test.cpp

@@ -219,7 +219,7 @@ TEST_F(TransformationTestsF, TransposeMatmulFusion8) {
 
         auto matmul = std::make_shared<ov::op::v0::MatMul>(transpose_a, input_b);
 
-        model = std::make_shared<ov::Model>(ov::NodeVector{matmul}, ov::ParameterVector{input_a, input_b});
+        model = std::make_shared<ov::Model>(ov::OutputVector{matmul}, ov::ParameterVector{input_a, input_b});
         manager.register_pass<TransposeFusion>();
 
         model_ref = model->clone();
@@ -238,7 +238,7 @@ TEST_F(TransformationTestsF, TransposeMatmulFusion9) {
 
         auto matmul = std::make_shared<ov::op::v0::MatMul>(transpose_a, input_b);
 
-        model = std::make_shared<ov::Model>(ov::NodeVector{matmul}, ov::ParameterVector{input_a, input_b});
+        model = std::make_shared<ov::Model>(ov::OutputVector{matmul}, ov::ParameterVector{input_a, input_b});
         bool support_immad = false;
         manager.register_pass<TransposeFusion>(support_immad);
 

src/plugins/intel_gpu/tests/unit/transformations/transpose_vlsdpa_fusion_test.cpp

@@ -56,7 +56,7 @@ std::shared_ptr<ov::Model> build_model() {
     auto transpose_o = std::make_shared<Transpose>(vlsdpa, Constant::create(element::i64, Shape{3}, {1,0,2}));
     transpose_o->set_friendly_name("transpose_o");
 
-    return std::make_shared<ov::Model>(NodeVector{transpose_o}, ParameterVector{q, k, v, cuseq_mask});
+    return std::make_shared<ov::Model>(OutputVector{transpose_o}, ParameterVector{q, k, v, cuseq_mask});
 }
 
 std::shared_ptr<ov::Model> build_target_model() {
@@ -77,7 +77,7 @@ std::shared_ptr<ov::Model> build_target_model() {
                                                                           v,
                                                                           cuseq_mask});
 
-    return std::make_shared<ov::Model>(NodeVector{vlsdpa}, ParameterVector{q, k, v, cuseq_mask});
+    return std::make_shared<ov::Model>(OutputVector{vlsdpa}, ParameterVector{q, k, v, cuseq_mask});
 }
 };   // namespace
 

src/plugins/template/tests/functional/op_reference/atanh.cpp

@@ -9,7 +9,6 @@
 #include <limits>
 
 #include "base_reference_test.hpp"
-#include "openvino/runtime/allocator.hpp"
 
 using namespace ov;
 

src/plugins/template/tests/functional/op_reference/base_reference_test.cpp

@@ -10,7 +10,6 @@
 #include "common_test_utils/ov_tensor_utils.hpp"
 #include "functional_test_utils/skip_tests_config.hpp"
 #include "openvino/core/type/element_type.hpp"
-#include "openvino/runtime/allocator.hpp"
 #include "openvino/runtime/tensor.hpp"
 #include "transformations/utils/utils.hpp"
 

src/plugins/template/tests/functional/op_reference/base_reference_test.hpp

@@ -7,7 +7,6 @@
 #include "openvino/core/shape.hpp"
 #include "openvino/core/type/element_type.hpp"
 #include "openvino/core/type/element_type_traits.hpp"
-#include "openvino/runtime/allocator.hpp"
 #include "openvino/runtime/core.hpp"
 #include "openvino/runtime/tensor.hpp"