diff --git a/src/core/include/openvino/op/squeeze.hpp b/src/core/include/openvino/op/squeeze.hpp
index 8c27f29d66df66..dde456aa2eef47 100644
--- a/src/core/include/openvino/op/squeeze.hpp
+++ b/src/core/include/openvino/op/squeeze.hpp
@@ -4,7 +4,7 @@
 
 #pragma once
 
-#include "openvino/op/op.hpp"
+#include "openvino/op/util/squeeze_base.hpp"
 
 namespace ov {
 namespace op {
@@ -12,30 +12,65 @@ namespace v0 {
 /// \brief Squeeze operation.
 ///
 /// \ingroup ov_ops_cpp_api
-class OPENVINO_API Squeeze : public Op {
+class OPENVINO_API Squeeze : public util::SqueezeBase {
 public:
     OPENVINO_OP("Squeeze", "opset1");
 
     Squeeze();
-    Squeeze(const Output<Node>& data, const Output<Node>& axes);
+    /// \brief Constructs a squeeze v0 operation.
+    ///
+    /// \param data Input tensor with data
     Squeeze(const Output<Node>& data);
+    /// \brief Constructs a squeeze v0 operation.
+    ///
+    /// \param data Input tensor with data
+    /// \param axis The axis along which to squeeze the input tensor.
+    Squeeze(const Output<Node>& data, const Output<Node>& axes);
 
     void validate_and_infer_types() override;
     bool evaluate(TensorVector& outputs, const TensorVector& inputs) const override;
-    bool has_evaluate() const override;
-    bool evaluate_lower(TensorVector& outputs) const override;
-    bool evaluate_upper(TensorVector& outputs) const override;
-    bool evaluate_symbol(TensorSymbolVector& output_symbols) const override;
-    bool constant_fold(OutputVector& output_values, const OutputVector& inputs_values) override;
-    bool can_constant_fold(const OutputVector& inputs_values) const override;
 
     std::shared_ptr<Node> clone_with_new_inputs(const OutputVector& new_args) const override;
 
-    bool is_dynamic() const override;
-
 private:
     Output<Node> get_default_axes_input() const;
 };
 }  // namespace v0
+
+namespace v15 {
+/// \brief Squeeze operation.
+///
+/// \ingroup ov_ops_cpp_api
+class OPENVINO_API Squeeze : public util::SqueezeBase {
+public:
+    OPENVINO_OP("Squeeze", "opset15");
+
+    Squeeze();
+    /// \brief Constructs a squeeze v15 operation.
+    ///
+    /// \param data Input tensor with data
+    /// \param allow_axis_skip Shape inference result dynamic rank if selected axis has 1 in range of its dynamic
+    Squeeze(const Output<Node>& data, const bool allow_axis_skip = false);
+    /// \brief Constructs a squeeze v15 operation.
+    ///
+    /// \param data Input tensor with data
+    /// \param axis The axis along which to squeeze the input tensor.
+    /// \param allow_axis_skip Shape inference result dynamic rank if selected axis has 1 in range of its dynamic
+    Squeeze(const Output<Node>& data, const Output<Node>& axes, const bool allow_axis_skip = false);
+
+    void validate_and_infer_types() override;
+    bool evaluate(TensorVector& outputs, const TensorVector& inputs) const override;
+
+    std::shared_ptr<Node> clone_with_new_inputs(const OutputVector& new_args) const override;
+
+    bool visit_attributes(AttributeVisitor& visitor) override;
+
+    bool get_allow_axis_skip() const;
+
+private:
+    Output<Node> get_default_axes_input() const;
+    bool m_allow_axis_skip{};
+};
+}  // namespace v15
 }  // namespace op
 }  // namespace ov
diff --git a/src/core/include/openvino/op/util/squeeze_base.hpp b/src/core/include/openvino/op/util/squeeze_base.hpp
new file mode 100644
index 00000000000000..50d960824e10d2
--- /dev/null
+++ b/src/core/include/openvino/op/util/squeeze_base.hpp
@@ -0,0 +1,39 @@
+// Copyright (C) 2018-2024 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include "openvino/op/op.hpp"
+
+namespace ov {
+namespace op {
+namespace util {
+/// \brief Squeeze operation.
+///
+/// \ingroup ov_ops_cpp_api
+class OPENVINO_API SqueezeBase : public Op {
+public:
+    OPENVINO_OP("Squeeze", "util");
+    SqueezeBase() = default;
+    /// \brief Constructs a squeeze operation.
+    ///
+    /// \param data Input tensor with data
+    SqueezeBase(const Output<Node>& data);
+    /// \brief Constructs a squeeze operation.
+    ///
+    /// \param data Input tensor with data
+    /// \param axis The axis along which to squeeze the input tensor.
+    SqueezeBase(const Output<Node>& data, const Output<Node>& axes);
+
+    bool has_evaluate() const override;
+    bool evaluate_lower(TensorVector& outputs) const override;
+    bool evaluate_upper(TensorVector& outputs) const override;
+    bool evaluate_symbol(TensorSymbolVector& output_symbols) const override;
+    bool can_constant_fold(const OutputVector& inputs_values) const override;
+    bool constant_fold(OutputVector& output_values, const OutputVector& inputs_values) override;
+    bool is_dynamic() const override;
+};
+}  // namespace util
+}  // namespace op
+}  // namespace ov
diff --git a/src/core/include/openvino/opsets/opset15_tbl.hpp b/src/core/include/openvino/opsets/opset15_tbl.hpp
index 9a49e421f9ad8e..8d12420719bb6b 100644
--- a/src/core/include/openvino/opsets/opset15_tbl.hpp
+++ b/src/core/include/openvino/opsets/opset15_tbl.hpp
@@ -97,7 +97,7 @@ _OPENVINO_OP_REG(Sqrt, ov::op::v0)
 _OPENVINO_OP_REG(SpaceToDepth, ov::op::v0)
 _OPENVINO_OP_REG(Split, ov::op::v1)
 _OPENVINO_OP_REG(SquaredDifference, ov::op::v0)
-_OPENVINO_OP_REG(Squeeze, ov::op::v0)
+_OPENVINO_OP_REG(Squeeze, ov::op::v15)
 _OPENVINO_OP_REG(StridedSlice, ov::op::v1)
 _OPENVINO_OP_REG(Subtract, ov::op::v1)
 _OPENVINO_OP_REG(Tan, ov::op::v0)
diff --git a/src/core/shape_inference/include/squeeze_shape_inference.hpp b/src/core/shape_inference/include/squeeze_shape_inference.hpp
index ee71b5452db1c3..31eeea5d36a9ea 100644
--- a/src/core/shape_inference/include/squeeze_shape_inference.hpp
+++ b/src/core/shape_inference/include/squeeze_shape_inference.hpp
@@ -11,6 +11,117 @@
 namespace ov {
 namespace op {
 namespace v0 {
+template <class T, class TRShape = result_shape_t<T>>
+std::vector<TRShape> shape_infer(const Squeeze* op,
+                                 const std::vector<T>& input_shapes,
+                                 const ITensorAccessor& ta = make_tensor_accessor()) {
+    using DimType = typename T::value_type;
+
+    const auto number_of_inputs = input_shapes.size();
+    OPENVINO_ASSERT(!input_shapes.empty());
+
+    const auto& arg_shape = input_shapes[0];
+    const auto& arg_rank = arg_shape.rank();
+    auto output_shapes = std::vector<TRShape>(1);
+    auto& output_shape = output_shapes[0];
+
+    std::unique_ptr<std::set<int64_t>> unique_axes;
+
+    if (number_of_inputs == 1) {
+        unique_axes.reset(new std::set<int64_t>());
+    } else if (number_of_inputs == 2) {
+        const auto& axes_shape = input_shapes[1];
+        NODE_VALIDATION_CHECK(op,
+                              axes_shape.is_dynamic() || ov::util::is_rank_compatible_any_of(axes_shape.rank(), {0, 1}),
+                              "Second input (axes) should not be of rank higher than 1. Got: ",
+                              axes_shape.rank().get_length());
+
+        std::vector<int64_t> axes;
+        if (arg_rank.is_static() && axes_shape.is_static()) {
+            if (auto axes = get_input_const_data_as<TRShape, int64_t>(op, 1, ta)) {
+                // The values of `axes` input are known
+                ov::util::try_normalize_axes(*axes, arg_rank, *op);
+                unique_axes.reset(new std::set<int64_t>(axes->cbegin(), axes->cend()));
+            } else if (arg_rank.get_length() > 0 && shape_size(axes_shape.to_shape()) == 1) {
+                // The `axes` input is a single element tensor which is unique by definition, deducing output rank
+                const auto has_squeezable_dim =
+                    std::any_of(arg_shape.cbegin(), arg_shape.cend(), [](const DimType& dim) {
+                        return dim.compatible(1);
+                    });
+                if (has_squeezable_dim) {
+                    output_shape = PartialShape::dynamic(arg_rank.get_length() - 1);
+                } else {
+                    output_shape = arg_shape;
+                }
+                return output_shapes;
+            }
+        }
+    } else {
+        // Invalid number of inputs, empty error message for backward compatibility.
+        NODE_VALIDATION_CHECK(op, false);
+    }
+
+    if (arg_rank.is_static() && (unique_axes != nullptr)) {
+        output_shape.resize(0);
+        if (unique_axes->empty()) {
+            // if only first input provided or axes are empty remove all dimensions equal to 1.
+            if (std::any_of(arg_shape.cbegin(), arg_shape.cend(), [](const DimType& d) {
+                    return d.is_dynamic() && d.compatible(1);
+                })) {
+                // we are unsure if dynamic dimensions would be equal to 1 or not, so we set dynamic output rank
+                output_shape = PartialShape::dynamic();
+                return output_shapes;
+            } else {
+                std::copy_if(arg_shape.cbegin(),
+                             arg_shape.cend(),
+                             std::back_inserter(output_shape),
+                             [](const DimType& dim) {
+                                 return !dim.compatible(1);
+                             });
+            }
+        } else {
+            int64_t idx = 0;
+            auto rm_axis_iter = unique_axes->cbegin();
+            auto rm_axis_end = unique_axes->cend();
+
+            // Returns true if dimension not squeezable on axis from input axes.
+            const auto not_squeezable_at_axis = [&rm_axis_iter, &rm_axis_end, &idx](const DimType& dim) {
+                if ((rm_axis_iter != rm_axis_end) && (*rm_axis_iter == idx++)) {
+                    ++rm_axis_iter;
+                    // Ignore: Pointed by axis, but not squeezable
+                    return !dim.compatible(1);
+                } else {
+                    return true;
+                }
+            };
+
+            std::copy_if(arg_shape.cbegin(),
+                         arg_shape.cend(),
+                         std::back_inserter(output_shape),
+                         not_squeezable_at_axis);
+        }
+    } else {
+        output_shape = PartialShape::dynamic();
+    }
+    return output_shapes;
+}
+}  // namespace v0
+
+namespace v15 {
+template <typename T>
+bool apply_allow_axis_skip(const ov::op::v15::Squeeze* const op,
+                           const std::unique_ptr<std::set<int64_t>>& unique_axes,
+                           const T& arg_shape) {
+    using DimType = typename T::value_type;
+    int64_t i{-1};
+
+    return op->get_allow_axis_skip() &&
+           std::any_of(arg_shape.cbegin(), arg_shape.cend(), [&unique_axes, &i](const DimType& d) {
+               ++i;
+               // Squeeze result with dynamic rank if 1 is in range of selected dynamic dimension.
+               return d.is_dynamic() && d.compatible(1) && unique_axes->find(i) != unique_axes->end();
+           });
+}
 
 /**
  * \brief Do Squeeze shape inference.
@@ -59,7 +170,7 @@ std::vector<TRShape> shape_infer(const Squeeze* op,
                         return dim.compatible(1);
                     });
                 if (has_squeezable_dim) {
-                    output_shape = PartialShape::dynamic(arg_rank.get_length() - 1);
+                    output_shape = PartialShape::dynamic();
                 } else {
                     output_shape = arg_shape;
                 }
@@ -71,7 +182,9 @@ std::vector<TRShape> shape_infer(const Squeeze* op,
         NODE_VALIDATION_CHECK(op, false);
     }
 
-    if (arg_rank.is_static() && (unique_axes != nullptr)) {
+    if (!arg_rank.is_static() || (unique_axes == nullptr) || apply_allow_axis_skip(op, unique_axes, arg_shape)) {
+        output_shape = PartialShape::dynamic();
+    } else if (arg_rank.is_static() && (unique_axes != nullptr)) {
         output_shape.resize(0);
         if (unique_axes->empty()) {
             // if only first input provided or axes are empty remove all dimensions equal to 1.
@@ -115,6 +228,6 @@ std::vector<TRShape> shape_infer(const Squeeze* op,
     }
     return output_shapes;
 }
-}  // namespace v0
+}  // namespace v15
 }  // namespace op
 }  // namespace ov
diff --git a/src/core/src/op/squeeze.cpp b/src/core/src/op/squeeze.cpp
index 1b34a4e48a4faf..b79165ca4f5543 100644
--- a/src/core/src/op/squeeze.cpp
+++ b/src/core/src/op/squeeze.cpp
@@ -6,31 +6,19 @@
 
 #include <cstring>
 
-#include "bound_evaluate.hpp"
 #include "itt.hpp"
-#include "openvino/core/validation_util.hpp"
-#include "openvino/op/constant.hpp"
 #include "squeeze_shape_inference.hpp"
 
 namespace ov {
 namespace op {
 namespace v0 {
-namespace validate {
-namespace {
+Squeeze::Squeeze() : util::SqueezeBase() {}
 
-bool axes_has_and_set_bound(const Node& op) {
-    return (op.get_input_size() < 2) || op.get_input_tensor(1).has_and_set_bound();
-}
-}  // namespace
-}  // namespace validate
-
-Squeeze::Squeeze() : Op() {}
-
-Squeeze::Squeeze(const Output<Node>& data, const Output<Node>& axes) : Op({data, axes}) {
+Squeeze::Squeeze(const Output<Node>& data, const Output<Node>& axes) : util::SqueezeBase(data, axes) {
     constructor_validate_and_infer_types();
 }
 
-Squeeze::Squeeze(const Output<Node>& data) : Op({data}) {
+Squeeze::Squeeze(const Output<Node>& data) : util::SqueezeBase(data) {
     constructor_validate_and_infer_types();
 }
 
@@ -69,62 +57,68 @@ bool Squeeze::evaluate(TensorVector& outputs, const TensorVector& inputs) const
     return true;
 }
 
-bool Squeeze::has_evaluate() const {
-    OV_OP_SCOPE(v0_Squeeze_has_evaluate);
-    const auto validate_axes_type = [](const element::Type& et) -> bool {
-        switch (et) {
-        case element::i8:
-        case element::i16:
-        case element::i32:
-        case element::i64:
-        case element::u8:
-        case element::u16:
-        case element::u32:
-        case element::u64:
-            return true;
-        default:
-            return false;
-        }
-    };
-
-    return (get_input_size() < 2) || validate_axes_type(get_input_element_type(1));
-}
+}  // namespace v0
 
-bool Squeeze::evaluate_lower(TensorVector& output_values) const {
-    OV_OP_SCOPE(v0_Squeeze_evaluate_lower);
-    return validate::axes_has_and_set_bound(*this) && default_lower_bound_evaluator(this, output_values);
+namespace v15 {
+Squeeze::Squeeze() : util::SqueezeBase() {}
+
+Squeeze::Squeeze(const Output<Node>& data, const bool allow_axis_skip)
+    : util::SqueezeBase(data),
+      m_allow_axis_skip{allow_axis_skip} {
+    constructor_validate_and_infer_types();
 }
 
-bool Squeeze::evaluate_upper(TensorVector& output_values) const {
-    OV_OP_SCOPE(v0_Squeeze_evaluate_upper);
-    return validate::axes_has_and_set_bound(*this) && default_upper_bound_evaluator(this, output_values);
+Squeeze::Squeeze(const Output<Node>& data, const Output<Node>& axes, const bool allow_axis_skip)
+    : util::SqueezeBase(data, axes),
+      m_allow_axis_skip{allow_axis_skip} {
+    constructor_validate_and_infer_types();
 }
 
-bool Squeeze::evaluate_symbol(TensorSymbolVector& output_symbols) const {
-    return validate::axes_has_and_set_bound(*this) && ov::util::default_symbol_evaluator(this, output_symbols);
+std::shared_ptr<Node> Squeeze::clone_with_new_inputs(const OutputVector& new_args) const {
+    OV_OP_SCOPE(v15_Squeeze_clone_with_new_inputs);
+    check_new_args_count(this, new_args);
+
+    switch (new_args.size()) {
+    case 1:
+        return std::make_shared<Squeeze>(new_args[0], m_allow_axis_skip);
+    case 2:
+        return std::make_shared<Squeeze>(new_args[0], new_args[1], m_allow_axis_skip);
+    default:
+        OPENVINO_THROW("Incorrect number of new arguments");
+    }
 }
 
-bool Squeeze::can_constant_fold(const OutputVector& inputs_values) const {
-    return get_output_partial_shape(0).is_static() && !is_const_fold_disabled();
+void Squeeze::validate_and_infer_types() {
+    OV_OP_SCOPE(v15_Squeeze_validate_and_infer_types);
+
+    const auto input_shapes = ov::util::get_node_input_partial_shapes(*this);
+    const auto output_shapes = shape_infer(this, input_shapes);
+
+    set_output_type(0, get_input_element_type(0), output_shapes[0]);
 }
 
-bool Squeeze::constant_fold(OutputVector& output_values, const OutputVector& inputs_values) {
-    OV_OP_SCOPE(v0_Squeeze_constant_fold);
-    if (!can_constant_fold(inputs_values)) {
-        return false;
-    }
+bool Squeeze::evaluate(TensorVector& outputs, const TensorVector& inputs) const {
+    OV_OP_SCOPE(v15_Squeeze_evaluate);
+    OPENVINO_ASSERT(outputs.size() == 1);
 
-    if (auto data_const = std::dynamic_pointer_cast<Constant>(inputs_values[0].get_node_shared_ptr())) {
-        const auto& shape = get_output_shape(0);
-        output_values[0] = std::make_shared<Constant>(*data_const, shape);
-        return true;
-    }
-    return false;
+    const auto output_shapes =
+        shape_infer(this, ov::util::get_tensors_partial_shapes(inputs), make_tensor_accessor(inputs));
+    outputs[0].set_shape(output_shapes.front().get_shape());
+
+    std::memcpy(outputs[0].data(), inputs[0].data(), outputs[0].get_byte_size());
+    return true;
 }
 
-bool Squeeze::is_dynamic() const {
-    return get_output_partial_shape(0).is_dynamic();
+bool Squeeze::visit_attributes(AttributeVisitor& visitor) {
+    OV_OP_SCOPE(v15_Squeeze_visit_attributes);
+    visitor.on_attribute("allow_axis_skip", m_allow_axis_skip);
+    return true;
 }
-}  // namespace v0
+
+bool Squeeze::get_allow_axis_skip() const {
+    OV_OP_SCOPE(v15_Squeeze_get_allow_axis_skip);
+    return m_allow_axis_skip;
+}
+}  // namespace v15
 }  // namespace op
 }  // namespace ov
diff --git a/src/core/src/op/util/squeeze_base.cpp b/src/core/src/op/util/squeeze_base.cpp
new file mode 100644
index 00000000000000..be5a20cbb58620
--- /dev/null
+++ b/src/core/src/op/util/squeeze_base.cpp
@@ -0,0 +1,91 @@
+#include "openvino/op/util/squeeze_base.hpp"
+
+#include "bound_evaluate.hpp"
+#include "itt.hpp"
+#include "openvino/core/validation_util.hpp"
+#include "openvino/op/constant.hpp"
+
+namespace ov {
+namespace op {
+
+namespace validate {
+namespace {
+
+bool axes_has_and_set_bound(const Node& op) {
+    return (op.get_input_size() < 2) || op.get_input_tensor(1).has_and_set_bound();
+}
+}  // namespace
+}  // namespace validate
+
+namespace util {
+SqueezeBase::SqueezeBase(const Output<Node>& data, const Output<Node>& axes) : Op({data, axes}) {
+    constructor_validate_and_infer_types();
+}
+
+SqueezeBase::SqueezeBase(const Output<Node>& data) : Op({data}) {
+    constructor_validate_and_infer_types();
+}
+
+bool SqueezeBase::has_evaluate() const {
+    OV_OP_SCOPE(util_SqueezeBase_has_evaluate);
+    const auto validate_axes_type = [](const element::Type& et) -> bool {
+        switch (et) {
+        case element::i8:
+        case element::i16:
+        case element::i32:
+        case element::i64:
+        case element::u8:
+        case element::u16:
+        case element::u32:
+        case element::u64:
+            return true;
+        default:
+            return false;
+        }
+    };
+
+    return (get_input_size() < 2) || validate_axes_type(get_input_element_type(1));
+}
+
+bool SqueezeBase::evaluate_lower(TensorVector& output_values) const {
+    OV_OP_SCOPE(util_SqueezeBase_evaluate_lower);
+    return validate::axes_has_and_set_bound(*this) && default_lower_bound_evaluator(this, output_values);
+}
+
+bool SqueezeBase::evaluate_upper(TensorVector& output_values) const {
+    OV_OP_SCOPE(util_SqueezeBase_evaluate_upper);
+    return validate::axes_has_and_set_bound(*this) && default_upper_bound_evaluator(this, output_values);
+}
+
+bool SqueezeBase::evaluate_symbol(TensorSymbolVector& output_symbols) const {
+    OV_OP_SCOPE(util_SqueezeBase_evaluate_symbol);
+    return validate::axes_has_and_set_bound(*this) && ov::util::default_symbol_evaluator(this, output_symbols);
+}
+
+bool SqueezeBase::can_constant_fold(const OutputVector& inputs_values) const {
+    OV_OP_SCOPE(util_SqueezeBase_can_constant_fold);
+    return get_output_partial_shape(0).is_static() && !is_const_fold_disabled();
+}
+
+bool SqueezeBase::constant_fold(OutputVector& output_values, const OutputVector& inputs_values) {
+    OV_OP_SCOPE(util_SqueezeBase_constant_fold);
+    if (!can_constant_fold(inputs_values)) {
+        return false;
+    }
+
+    if (auto data_const = std::dynamic_pointer_cast<ov::op::v0::Constant>(inputs_values[0].get_node_shared_ptr())) {
+        const auto& shape = get_output_shape(0);
+        output_values[0] = std::make_shared<ov::op::v0::Constant>(*data_const, shape);
+        return true;
+    }
+    return false;
+}
+
+bool SqueezeBase::is_dynamic() const {
+    OV_OP_SCOPE(util_SqueezeBase_is_dynamic);
+    return get_output_partial_shape(0).is_dynamic();
+}
+
+}  // namespace util
+}  // namespace op
+}  // namespace ov
diff --git a/src/core/tests/CMakeLists.txt b/src/core/tests/CMakeLists.txt
index c3ed58783ac946..89acd7bd1809d0 100644
--- a/src/core/tests/CMakeLists.txt
+++ b/src/core/tests/CMakeLists.txt
@@ -18,6 +18,7 @@ set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/threading.cpp
 if(SUGGEST_OVERRIDE_SUPPORTED)
     set_source_files_properties(ov_tensor_test.cpp
                                 type_prop/multiclass_nms.cpp
+                                type_prop/squeeze.cpp
                                 PROPERTIES COMPILE_OPTIONS -Wno-suggest-override)
 endif()
 
diff --git a/src/core/tests/type_prop/squeeze.cpp b/src/core/tests/type_prop/squeeze.cpp
index c7d81fd97c2786..7be05de1876d9f 100644
--- a/src/core/tests/type_prop/squeeze.cpp
+++ b/src/core/tests/type_prop/squeeze.cpp
@@ -7,193 +7,261 @@
 #include "common_test_utils/test_assertions.hpp"
 #include "common_test_utils/type_prop.hpp"
 #include "openvino/op/broadcast.hpp"
-#include "openvino/op/constant.hpp"
-#include "openvino/op/gather.hpp"
-#include "openvino/op/shape_of.hpp"
-#include "openvino/op/unsqueeze.hpp"
 #include "sequence_generator.hpp"
 
 using namespace std;
 using namespace ov;
 using namespace testing;
 
-TEST(type_prop, squeeze_axes_invalid_value) {
+namespace {
+
+template <typename TSqueeze>
+class SqueezelOperator : public TypePropOpTest<TSqueeze> {};
+
+using SqueezeTypes = ::testing::Types<op::v0::Squeeze, op::v15::Squeeze>;
+
+TYPED_TEST_SUITE(SqueezelOperator, SqueezeTypes);
+
+TYPED_TEST(SqueezelOperator, squeeze_axes_invalid_value) {
     auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
     auto axes_node = make_shared<ov::op::v0::Constant>(element::u64, Shape{2}, vector<int64_t>{0, 2});
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+    const auto squeeze = this->make_op(param, axes_node);
 
     EXPECT_EQ(squeeze->get_element_type(), element::f32);
     EXPECT_EQ(squeeze->get_output_partial_shape(0), (PartialShape{2, 3, 4}));
 }
 
-TEST(type_prop, squeeze_single_input) {
+TYPED_TEST(SqueezelOperator, squeeze_single_input) {
     auto param = make_shared<ov::op::v0::Parameter>(element::f32, PartialShape{1, -1, 3, 4});
-    auto s = make_shared<op::v0::Squeeze>(param);
-    EXPECT_EQ(s->get_output_partial_shape(0), PartialShape::dynamic());
+    const auto squeeze = this->make_op(param);
+    EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic());
 }
 
-TEST(type_prop, squeeze_axes_invalid_rank) {
+TYPED_TEST(SqueezelOperator, squeeze_axes_invalid_rank) {
     auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 2, 3, 4});
     auto axes_node = make_shared<ov::op::v0::Constant>(element::i32, Shape{2, 1}, vector<int32_t>{0, 2});
 
-    OV_EXPECT_THROW(auto s = make_shared<op::v0::Squeeze>(param, axes_node),
+    OV_EXPECT_THROW(const auto squeeze = this->make_op(param, axes_node),
                     NodeValidationFailure,
                     HasSubstr("Second input (axes) should not be of rank higher than 1."));
 }
 
-TEST(type_prop, squeeze_incorrect_negative_axes) {
+TYPED_TEST(SqueezelOperator, squeeze_incorrect_negative_axes) {
     auto param = make_shared<ov::op::v0::Parameter>(element::f32, Shape{1, 4, 1, 4, 1, 8});
     auto axes_node = make_shared<ov::op::v0::Constant>(element::i64, Shape{2}, vector<int64_t>{-6, -10});
 
-    OV_EXPECT_THROW(auto s = make_shared<op::v0::Squeeze>(param, axes_node),
+    OV_EXPECT_THROW(const auto squeeze = this->make_op(param, axes_node),
                     ov::Exception,
                     HasSubstr("Axis -10 out of the tensor rank range"));
 }
 
-TEST(type_prop, squeeze_data_static_param_axes_1D_single_elem_static_shape_no_squeezable_dims) {
+TYPED_TEST(SqueezelOperator, squeeze_data_static_param_axes_1D_single_elem_static_shape_no_squeezable_dims) {
     auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{2, 2, 4});
     const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{1});
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+    const auto squeeze = this->make_op(param, axes_node);
 
     EXPECT_EQ(squeeze->get_element_type(), element::f32);
     EXPECT_EQ(squeeze->get_output_partial_shape(0), (PartialShape{2, 2, 4}));
 }
 
-TEST(type_prop, squeeze_data_static_param_axes_1D_two_elem_static_shape_squeezable_dims_two) {
+TYPED_TEST(SqueezelOperator, squeeze_data_static_param_axes_1D_two_elem_static_shape_squeezable_dims_two) {
     auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{1, 2, 1, 4});
     const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{2});
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+    const auto squeeze = this->make_op(param, axes_node);
 
     EXPECT_EQ(squeeze->get_element_type(), element::f32);
     EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic());
 }
 
-TEST(type_prop, squeeze_data_static_param_axes_1D_two_elem_static_shape_squeezable_dims_one) {
+TYPED_TEST(SqueezelOperator, squeeze_data_static_param_axes_1D_two_elem_static_shape_squeezable_dims_one) {
     auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{2, 1, 4});
     const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{2});
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+    const auto squeeze = this->make_op(param, axes_node);
 
     EXPECT_EQ(squeeze->get_element_type(), element::f32);
     EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic());
 }
 
-TEST(type_prop, squeeze_data_static_param_axes_1D_single_elem_static_shape_squeezable_dims_one) {
+TEST(TypePropSqueezelOperatorV0, squeeze_data_static_param_axes_1D_single_elem_static_shape_squeezable_dims_one) {
     auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{2, 1, 4});
     const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{1});
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+    const auto squeeze = std::make_shared<ov::op::v0::Squeeze>(param, axes_node);
 
     EXPECT_EQ(squeeze->get_element_type(), element::f32);
     EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic(2));
 }
 
-TEST(type_prop, squeeze_data_static_param_axes_scalar_static_shape_squeezable_dims_one) {
+TEST(TypePropSqueezelOperatorV15, squeeze_data_static_param_axes_1D_single_elem_static_shape_squeezable_dims_one) {
+    auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{2, 1, 4});
+    const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{1});
+    const auto squeeze = std::make_shared<ov::op::v15::Squeeze>(param, axes_node);
+
+    EXPECT_EQ(squeeze->get_element_type(), element::f32);
+    EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic());
+}
+
+TEST(TypePropSqueezelOperatorV0, squeeze_data_static_param_axes_scalar_static_shape_squeezable_dims_one) {
     auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{2, 1, 4});
     const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{});
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+    const auto squeeze = std::make_shared<ov::op::v0::Squeeze>(param, axes_node);
 
     EXPECT_EQ(squeeze->get_element_type(), element::f32);
     EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic(2));
 }
 
-TEST(type_prop, squeeze_data_scalar_param_axes_1D_single_elem_static_shape) {
+TEST(TypePropSqueezelOperatorV15, squeeze_data_static_param_axes_scalar_static_shape_squeezable_dims_one) {
+    auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{2, 1, 4});
+    const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{});
+    const auto squeeze = std::make_shared<ov::op::v15::Squeeze>(param, axes_node);
+
+    EXPECT_EQ(squeeze->get_element_type(), element::f32);
+    EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic());
+}
+
+TYPED_TEST(SqueezelOperator, squeeze_data_scalar_param_axes_1D_single_elem_static_shape) {
     auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{});
     const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{1});
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+    const auto squeeze = this->make_op(param, axes_node);
 
     EXPECT_EQ(squeeze->get_element_type(), element::f32);
     EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic());
 }
 
-TEST(type_prop, squeeze_data_dynamic_param_axes_1D_two_elem_static_shape_squeezable_dims_equal) {
+TYPED_TEST(SqueezelOperator, squeeze_data_dynamic_param_axes_1D_two_elem_static_shape_squeezable_dims_equal) {
     auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{-1, {2, 8}, {1, 3}, {4, -1}});
     const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{2});
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+    const auto squeeze = this->make_op(param, axes_node);
 
     EXPECT_EQ(squeeze->get_element_type(), element::f32);
     EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic());
 }
 
-TEST(type_prop, squeeze_data_static_param_axes_1D_two_elem_static_shape_squeezable_dims_more) {
+TYPED_TEST(SqueezelOperator, squeeze_data_static_param_axes_1D_two_elem_static_shape_squeezable_dims_more) {
     auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{1, 2, 1, 3, 1});
     const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{2});
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+    const auto squeeze = this->make_op(param, axes_node);
 
     EXPECT_EQ(squeeze->get_element_type(), element::f32);
     EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic());
 }
 
-TEST(type_prop, squeeze_data_static_param_axes_1D_single_elem_static_shape_squeezable_dims_more) {
+TEST(TypePropSqueezelOperatorV0, squeeze_data_static_param_axes_1D_single_elem_static_shape_squeezable_dims_more) {
     auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{1, 2, 1, 3, 1});
     const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{1});
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+    const auto squeeze = std::make_shared<ov::op::v0::Squeeze>(param, axes_node);
 
     EXPECT_EQ(squeeze->get_element_type(), element::f32);
     EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic(4));
 }
 
-TEST(type_prop, squeeze_data_static_param_axes_scalar_static_shape_squeezable_dims_more) {
+TEST(TypePropSqueezelOperatorV15, squeeze_data_static_param_axes_1D_single_elem_static_shape_squeezable_dims_more) {
+    auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{1, 2, 1, 3, 1});
+    const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{1});
+    const auto squeeze = std::make_shared<ov::op::v15::Squeeze>(param, axes_node);
+
+    EXPECT_EQ(squeeze->get_element_type(), element::f32);
+    EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic());
+}
+
+TEST(TypePropSqueezelOperatorV0, squeeze_data_static_param_axes_scalar_static_shape_squeezable_dims_more) {
     auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{1, 2, 1, 3, 1});
     const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{});
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+    const auto squeeze = std::make_shared<ov::op::v0::Squeeze>(param, axes_node);
 
     EXPECT_EQ(squeeze->get_element_type(), element::f32);
     EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic(4));
 }
 
-TEST(type_prop, squeeze_data_dynamic_param_axes_1D_two_elem_static_shape_squeezable_dims_more) {
+TEST(TypePropSqueezelOperatorV15, squeeze_data_static_param_axes_scalar_static_shape_squeezable_dims_more) {
+    auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{1, 2, 1, 3, 1});
+    const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{});
+    const auto squeeze = std::make_shared<ov::op::v15::Squeeze>(param, axes_node);
+
+    EXPECT_EQ(squeeze->get_element_type(), element::f32);
+    EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic());
+}
+
+TYPED_TEST(SqueezelOperator, squeeze_data_dynamic_param_axes_1D_two_elem_static_shape_squeezable_dims_more) {
     auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{-1, {2, 8}, {1, 3}, {4, -1}});
     const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{2});
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+    const auto squeeze = this->make_op(param, axes_node);
 
     EXPECT_EQ(squeeze->get_element_type(), element::f32);
     EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic());
 }
 
-TEST(type_prop, squeeze_data_dynamic_param_axes_1D_single_elem_static_shape_squeezable_dims_more) {
+TEST(TypePropSqueezelOperatorV0, squeeze_data_dynamic_param_axes_1D_single_elem_static_shape_squeezable_dims_more) {
     auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{-1, {2, 8}, {1, 3}, {4, -1}});
     const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{1});
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+    const auto squeeze = std::make_shared<ov::op::v0::Squeeze>(param, axes_node);
 
     EXPECT_EQ(squeeze->get_element_type(), element::f32);
     EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic(3));
 }
 
-TEST(type_prop, squeeze_data_dynamic_param_axes_scalar_static_shape_squeezable_dims_more) {
+TEST(TypePropSqueezelOperatorV15, squeeze_data_dynamic_param_axes_1D_single_elem_static_shape_squeezable_dims_more) {
+    auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{-1, {2, 8}, {1, 3}, {4, -1}});
+    const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{1});
+    const auto squeeze = std::make_shared<ov::op::v15::Squeeze>(param, axes_node);
+
+    EXPECT_EQ(squeeze->get_element_type(), element::f32);
+    EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic());
+}
+
+TEST(TypePropSqueezelOperatorV0, squeeze_data_dynamic_param_axes_scalar_static_shape_squeezable_dims_more) {
     auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{-1, {2, 8}, {1, 3}, {4, -1}});
     const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{});
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+    const auto squeeze = std::make_shared<ov::op::v0::Squeeze>(param, axes_node);
 
     EXPECT_EQ(squeeze->get_element_type(), element::f32);
     EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic(3));
 }
 
-TEST(type_prop, squeeze_data_dyamic_param_axes_1D_two_elem_static_shape_squeezable_dims_one) {
+TEST(TypePropSqueezelOperatorV15, squeeze_data_dynamic_param_axes_scalar_static_shape_squeezable_dims_more) {
+    auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{-1, {2, 8}, {1, 3}, {4, -1}});
+    const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{});
+    const auto squeeze = std::make_shared<ov::op::v15::Squeeze>(param, axes_node);
+
+    EXPECT_EQ(squeeze->get_element_type(), element::f32);
+    EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic());
+}
+
+TYPED_TEST(SqueezelOperator, squeeze_data_dyamic_param_axes_1D_two_elem_static_shape_squeezable_dims_one) {
     auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{2, -1, 4});
     const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{2});
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+    const auto squeeze = this->make_op(param, axes_node);
 
     EXPECT_EQ(squeeze->get_element_type(), element::f32);
     EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic());
 }
 
-TEST(type_prop, squeeze_data_dynamic_param_axes_1D_three_elem_static_shape_squeezable_dims_two) {
+TYPED_TEST(SqueezelOperator, squeeze_data_dynamic_param_axes_1D_three_elem_static_shape_squeezable_dims_two) {
     auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{-1, {2, 8}, {1, 3}, {4, -1}});
     const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{3});
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+    const auto squeeze = this->make_op(param, axes_node);
 
     EXPECT_EQ(squeeze->get_element_type(), element::f32);
     EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic());
 }
 
-TEST(type_prop, squeeze_data_dynamic_param_axes_1D_single_elem_static_shape_squeezable_dims_less) {
+TEST(TypePropSqueezelOperatorV0, squeeze_data_dynamic_param_axes_1D_single_elem_static_shape_squeezable_dims_less) {
     auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{-1, {2, 8}, {1, 3}, {4, -1}});
     const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{1});
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+    const auto squeeze = std::make_shared<ov::op::v0::Squeeze>(param, axes_node);
 
     EXPECT_EQ(squeeze->get_element_type(), element::f32);
     EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic(3));
 }
 
+TEST(TypePropSqueezelOperatorV15, squeeze_data_dynamic_param_axes_1D_single_elem_static_shape_squeezable_dims_less) {
+    auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, PartialShape{-1, {2, 8}, {1, 3}, {4, -1}});
+    const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{1});
+    const auto squeeze = std::make_shared<ov::op::v15::Squeeze>(param, axes_node);
+
+    EXPECT_EQ(squeeze->get_element_type(), element::f32);
+    EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic());
+}
+
 using SqueezeTypePropTestParam = std::tuple<PartialShape,          // Input shape
                                             std::vector<int64_t>,  // Squeeze axis
                                             PartialShape           // Expected shape
@@ -288,26 +356,44 @@ INSTANTIATE_TEST_SUITE_P(type_prop_shrink_shape_default_axes,
 
 TEST_P(SqueezeTest, partial_shape_dimension_propagation_const_axis_i32) {
     const auto axes_node = std::make_shared<ov::op::v0::Constant>(element::i32, Shape{axes.size()}, axes);
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
-
-    EXPECT_EQ(squeeze->get_element_type(), element::f32);
-    EXPECT_EQ(squeeze->get_output_partial_shape(0), exp_shape);
+    {
+        const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+        EXPECT_EQ(squeeze->get_element_type(), element::f32);
+        EXPECT_EQ(squeeze->get_output_partial_shape(0), exp_shape);
+    }
+    {
+        const auto squeeze = std::make_shared<op::v15::Squeeze>(param, axes_node);
+        EXPECT_EQ(squeeze->get_element_type(), element::f32);
+        EXPECT_EQ(squeeze->get_output_partial_shape(0), exp_shape);
+    }
 }
 
 TEST_P(SqueezeTest, partial_shape_dimension_propagation_parameter_axes_no_data) {
     const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape{Shape{axes.size()}});
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
-
-    EXPECT_EQ(squeeze->get_element_type(), element::f32);
-    EXPECT_TRUE(squeeze->get_output_partial_shape(0).compatible(exp_shape));
+    {
+        const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+        EXPECT_EQ(squeeze->get_element_type(), element::f32);
+        EXPECT_TRUE(squeeze->get_output_partial_shape(0).compatible(exp_shape));
+    }
+    {
+        const auto squeeze = std::make_shared<op::v15::Squeeze>(param, axes_node);
+        EXPECT_EQ(squeeze->get_element_type(), element::f32);
+        EXPECT_TRUE(squeeze->get_output_partial_shape(0).compatible(exp_shape));
+    }
 }
 
 TEST_P(SqueezeTest, partial_shape_dimension_propagation_dynamic_axes) {
     const auto axes_node = std::make_shared<ov::op::v0::Parameter>(element::u64, PartialShape::dynamic());
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
-
-    EXPECT_EQ(squeeze->get_element_type(), element::f32);
-    EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic());
+    {
+        const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+        EXPECT_EQ(squeeze->get_element_type(), element::f32);
+        EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic());
+    }
+    {
+        const auto squeeze = std::make_shared<op::v15::Squeeze>(param, axes_node);
+        EXPECT_EQ(squeeze->get_element_type(), element::f32);
+        EXPECT_EQ(squeeze->get_output_partial_shape(0), PartialShape::dynamic());
+    }
 }
 
 TEST_P(SqueezeTest, symbols_propagation) {
@@ -321,9 +407,14 @@ TEST_P(SqueezeTest, symbols_propagation) {
     param = make_shared<ov::op::v0::Parameter>(element::f32, p_shape);
 
     const auto axes_node = std::make_shared<ov::op::v0::Constant>(element::i32, Shape{axes.size()}, axes);
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
-
-    EXPECT_EQ(get_shape_symbols(squeeze->get_output_partial_shape(0)), exp_symbols);
+    {
+        const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+        EXPECT_EQ(get_shape_symbols(squeeze->get_output_partial_shape(0)), exp_symbols);
+    }
+    {
+        const auto squeeze = std::make_shared<op::v15::Squeeze>(param, axes_node);
+        EXPECT_EQ(get_shape_symbols(squeeze->get_output_partial_shape(0)), exp_symbols);
+    }
 }
 
 using SqueezeShapeTests = SqueezeTest;
@@ -336,10 +427,16 @@ INSTANTIATE_TEST_SUITE_P(type_prop_shrink_shape_no_axes,
 TEST_P(SqueezeShapeTests, shape_dimension_propagation_const_axis_i64) {
     param = std::make_shared<ov::op::v0::Parameter>(element::f64, p_shape.to_shape());
     const auto axes_node = std::make_shared<ov::op::v0::Constant>(element::i64, Shape{axes.size()}, axes);
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
-
-    EXPECT_EQ(squeeze->get_element_type(), element::f64);
-    EXPECT_EQ(squeeze->get_output_partial_shape(0), exp_shape.to_shape());
+    {
+        const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+        EXPECT_EQ(squeeze->get_element_type(), element::f64);
+        EXPECT_EQ(squeeze->get_output_partial_shape(0), exp_shape.to_shape());
+    }
+    {
+        const auto squeeze = std::make_shared<op::v15::Squeeze>(param, axes_node);
+        EXPECT_EQ(squeeze->get_element_type(), element::f64);
+        EXPECT_EQ(squeeze->get_output_partial_shape(0), exp_shape.to_shape());
+    }
 }
 
 using SqueezeNoAxesTest = SqueezeTest;
@@ -350,10 +447,16 @@ INSTANTIATE_TEST_SUITE_P(type_prop_shrink_shape_no_axes,
                          PrintToStringParamName());
 
 TEST_P(SqueezeNoAxesTest, partial_shape_dimension_propagation_no_axes) {
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param);
-
-    EXPECT_EQ(squeeze->get_element_type(), element::f32);
-    EXPECT_EQ(squeeze->get_output_partial_shape(0), exp_shape);
+    {
+        const auto squeeze = std::make_shared<op::v0::Squeeze>(param);
+        EXPECT_EQ(squeeze->get_element_type(), element::f32);
+        EXPECT_EQ(squeeze->get_output_partial_shape(0), exp_shape);
+    }
+    {
+        const auto squeeze = std::make_shared<op::v15::Squeeze>(param);
+        EXPECT_EQ(squeeze->get_element_type(), element::f32);
+        EXPECT_EQ(squeeze->get_output_partial_shape(0), exp_shape);
+    }
 }
 
 using SqueezeScalarAxisTest = SqueezeTest;
@@ -368,25 +471,35 @@ INSTANTIATE_TEST_SUITE_P(
 
 TEST_P(SqueezeScalarAxisTest, axis_value_as_vector) {
     const auto axes_node = std::make_shared<ov::op::v0::Constant>(element::i32, Shape{}, axes);
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
-
-    EXPECT_EQ(squeeze->get_element_type(), element::f32);
-    EXPECT_EQ(squeeze->get_output_partial_shape(0), exp_shape);
+    {
+        const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+        EXPECT_EQ(squeeze->get_element_type(), element::f32);
+        EXPECT_EQ(squeeze->get_output_partial_shape(0), exp_shape);
+    }
+    {
+        const auto squeeze = std::make_shared<op::v15::Squeeze>(param, axes_node);
+        EXPECT_EQ(squeeze->get_element_type(), element::f32);
+        EXPECT_EQ(squeeze->get_output_partial_shape(0), exp_shape);
+    }
 }
 
 TEST_P(SqueezeScalarAxisTest, axis_value_as_integer) {
     const auto axes_node = std::make_shared<ov::op::v0::Constant>(element::i32, Shape{}, axes.front());
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
-
-    EXPECT_EQ(squeeze->get_element_type(), element::f32);
-    EXPECT_EQ(squeeze->get_output_partial_shape(0), exp_shape);
+    {
+        const auto squeeze = std::make_shared<op::v0::Squeeze>(param, axes_node);
+        EXPECT_EQ(squeeze->get_element_type(), element::f32);
+        EXPECT_EQ(squeeze->get_output_partial_shape(0), exp_shape);
+    }
+    {
+        const auto squeeze = std::make_shared<op::v15::Squeeze>(param, axes_node);
+        EXPECT_EQ(squeeze->get_element_type(), element::f32);
+        EXPECT_EQ(squeeze->get_output_partial_shape(0), exp_shape);
+    }
 }
 
 using SqueezeBoundTest = UnSqueezeBoundTest;
 
-INSTANTIATE_TEST_SUITE_P(
-    type_prop_bounds_propagate,
-    SqueezeBoundTest,
+const auto test_values_in =
     Values(std::make_tuple(PartialShape::dynamic(6), PartialShape::dynamic(1)),
            std::make_tuple(PartialShape{Dimension(-1)}, PartialShape{Dimension(-1)}),
            std::make_tuple(PartialShape{Dimension::dynamic(), 8}, PartialShape{Dimension::dynamic()}),
@@ -394,34 +507,136 @@ INSTANTIATE_TEST_SUITE_P(
            std::make_tuple(PartialShape{Dimension(20, -1), Dimension::dynamic()}, PartialShape{{20, -1}}),
            std::make_tuple(PartialShape{Dimension(-1, 5), Dimension::dynamic()}, PartialShape{Dimension(-1, 5)}),
            std::make_tuple(PartialShape{15}, PartialShape{15}),
-           std::make_tuple(PartialShape{2, 6}, PartialShape{2})),
-    PrintToStringParamName());
+           std::make_tuple(PartialShape{2, 6}, PartialShape{2}));
+
+INSTANTIATE_TEST_SUITE_P(type_prop_bounds_propagate, SqueezeBoundTest, test_values_in, PrintToStringParamName());
 
 /**
  * \brief Check symbol and dynamic value propagation.
  *
  * Test use evaluate symbol, lower/upper.
  */
-TEST_P(SqueezeBoundTest, propagate_symbol_and_dynamic_value) {
+TEST_P(SqueezeBoundTest, propagate_symbol_and_dynamic_value_squeeze_v0) {
     PartialShape symboled_shape = PartialShape{p_shape};
 
     in_symbols = set_shape_symbols(symboled_shape);
 
-    constexpr auto et = element::i64;
-    const auto symboled_param = std::make_shared<ov::op::v0::Parameter>(et, symboled_shape);
-    const auto symboled_shape_of = std::make_shared<op::v0::ShapeOf>(symboled_param);
+    const auto squeeze = create_squeeze<op::v0::Squeeze>(symboled_shape);
+    const auto bc = std::make_shared<op::v3::Broadcast>(param, squeeze);
+
+    EXPECT_EQ(bc->get_output_partial_shape(0), exp_shape);
+    const auto symbols = get_shape_symbols(bc->get_output_partial_shape(0));
+    EXPECT_THAT(symbols, ElementsAre(in_symbols.front()));
+}
 
-    const auto zero = std::vector<int64_t>{0};
-    const auto axis = std::make_shared<op::v0::Constant>(et, Shape{}, zero);
-    const auto indices = std::make_shared<op::v0::Constant>(et, Shape{}, zero);
-    const auto gather = std::make_shared<op::v7::Gather>(symboled_shape_of, indices, axis);
-    const auto axis_1 = std::make_shared<op::v0::Constant>(et, Shape{2}, std::vector<int64_t>{0, 1});
-    const auto unsqueeze = std::make_shared<op::v0::Unsqueeze>(gather, axis_1);
-    const auto squeeze = std::make_shared<op::v0::Squeeze>(unsqueeze, axis);
+/**
+ * \brief Check symbol and dynamic value propagation.
+ *
+ * Test use evaluate symbol, lower/upper.
+ */
+TEST_P(SqueezeBoundTest, propagate_symbol_and_dynamic_value_squeeze_v15) {
+    PartialShape symboled_shape = PartialShape{p_shape};
+
+    in_symbols = set_shape_symbols(symboled_shape);
 
+    const auto squeeze = create_squeeze<op::v15::Squeeze>(symboled_shape);
     const auto bc = std::make_shared<op::v3::Broadcast>(param, squeeze);
 
     EXPECT_EQ(bc->get_output_partial_shape(0), exp_shape);
     const auto symbols = get_shape_symbols(bc->get_output_partial_shape(0));
     EXPECT_THAT(symbols, ElementsAre(in_symbols.front()));
 }
+
+using SqueezeAxesDynamicRankTestParam = decltype(std::tuple_cat(SqueezeTypePropTestParam{}, std::make_tuple(false)));
+class SqueezeAxesDynamicRank : public ::testing::TestWithParam<SqueezeAxesDynamicRankTestParam> {
+protected:
+    ov::PartialShape p_shape{}, exp_shape{};
+    std::vector<int64_t> axes{};
+    bool allow_axis_skip{};
+};
+
+INSTANTIATE_TEST_SUITE_P(
+    SqueezeAxesDynamicRankTests,
+    SqueezeAxesDynamicRank,
+    ::testing::Values(
+        std::make_tuple(PartialShape{1, 2, -1, 4}, std::vector<int64_t>{}, PartialShape::dynamic(), false),
+        std::make_tuple(PartialShape{1, 2, -1, 4}, std::vector<int64_t>{}, PartialShape::dynamic(), true),
+
+        std::make_tuple(PartialShape{1, 2, -1, 4}, std::vector<int64_t>{0}, PartialShape{2, -1, 4}, false),
+        std::make_tuple(PartialShape{1, 2, -1, 4}, std::vector<int64_t>{0}, PartialShape{2, -1, 4}, true),
+
+        std::make_tuple(PartialShape{1, 2, -1, 4}, std::vector<int64_t>{2}, PartialShape{1, 2, 4}, false),
+        std::make_tuple(PartialShape{1, 2, -1, 4}, std::vector<int64_t>{2}, PartialShape::dynamic(), true),
+
+        std::make_tuple(PartialShape{1, 2, -1, 4}, std::vector<int64_t>{0, 2}, PartialShape{2, 4}, false),
+        std::make_tuple(PartialShape{1, 2, -1, 4}, std::vector<int64_t>{0, 2}, PartialShape::dynamic(), true),
+
+        std::make_tuple(PartialShape{1, 2, -1, 4}, std::vector<int64_t>{1}, PartialShape{1, 2, -1, 4}, false),
+        std::make_tuple(PartialShape{1, 2, -1, 4}, std::vector<int64_t>{1}, PartialShape{1, 2, -1, 4}, true),
+
+        std::make_tuple(PartialShape{2, 4}, std::vector<int64_t>{1}, PartialShape{2, 4}, false),
+        std::make_tuple(PartialShape{2, 4}, std::vector<int64_t>{1}, PartialShape{2, 4}, true),
+
+        std::make_tuple(PartialShape{2, {3, 5}}, std::vector<int64_t>{}, PartialShape{2, {3, 5}}, false),
+        std::make_tuple(PartialShape{2, {3, 5}}, std::vector<int64_t>{}, PartialShape{2, {3, 5}}, true),
+
+        std::make_tuple(PartialShape{1, 2, -1}, std::vector<int64_t>{0, 1}, PartialShape{2, -1}, false),
+        std::make_tuple(PartialShape{1, 2, -1}, std::vector<int64_t>{0, 1}, PartialShape{2, -1}, true),
+
+        std::make_tuple(PartialShape{1, 2, -1}, std::vector<int64_t>{1}, PartialShape{1, 2, -1}, false),
+        std::make_tuple(PartialShape{1, 2, -1}, std::vector<int64_t>{1}, PartialShape{1, 2, -1}, true),
+
+        std::make_tuple(PartialShape{1, 1, -1}, std::vector<int64_t>{0, 1}, PartialShape{-1}, false),
+        std::make_tuple(PartialShape{1, 1, -1}, std::vector<int64_t>{0, 1}, PartialShape{-1}, true),
+
+        std::make_tuple(PartialShape{1, 1, -1}, std::vector<int64_t>{1}, PartialShape{1, -1}, false),
+        std::make_tuple(PartialShape{1, 1, -1}, std::vector<int64_t>{1}, PartialShape{1, -1}, true),
+
+        std::make_tuple(PartialShape{1, 2, 3}, std::vector<int64_t>{}, PartialShape{2, 3}, false),
+        std::make_tuple(PartialShape{1, 2, 3}, std::vector<int64_t>{}, PartialShape{2, 3}, true)));
+
+TEST_P(SqueezeAxesDynamicRank, squeeze_axes_dynamic_rank_param) {
+    const auto& params = GetParam();
+    p_shape = std::get<0>(params);
+    axes = std::get<1>(params);
+    exp_shape = std::get<2>(params);
+    allow_axis_skip = std::get<3>(params);
+
+    auto param = make_shared<ov::op::v0::Parameter>(element::f32, p_shape);
+    auto axes_node = make_shared<ov::op::v0::Constant>(element::u64, Shape{axes.size()}, axes);
+    const auto squeeze = std::make_shared<op::v15::Squeeze>(param, axes_node, allow_axis_skip);
+
+    EXPECT_EQ(squeeze->get_element_type(), element::f32);
+    EXPECT_EQ(squeeze->get_output_partial_shape(0), exp_shape);
+    EXPECT_EQ(squeeze->get_allow_axis_skip(), allow_axis_skip);
+}
+
+TEST(SqueezeDynamicAxis, squeeze_dynamic_non_const_single_axis) {
+    auto p_shape = PartialShape{1, 2, -1, 4};
+    auto exp_shape = PartialShape::dynamic();
+    auto allow_axis_skip = true;
+
+    auto param = make_shared<ov::op::v0::Parameter>(element::f32, p_shape);
+    auto axes_node = make_shared<ov::op::v0::Parameter>(element::i32, Shape{1});
+    const auto squeeze = std::make_shared<op::v15::Squeeze>(param, axes_node, allow_axis_skip);
+
+    EXPECT_EQ(squeeze->get_element_type(), element::f32);
+    EXPECT_EQ(squeeze->get_output_partial_shape(0), exp_shape);
+    EXPECT_EQ(squeeze->get_allow_axis_skip(), allow_axis_skip);
+}
+
+TEST(SqueezeDynamicAxis, squeeze_dynamic_non_const_axes) {
+    auto p_shape = PartialShape{1, 2, -1, 4};
+    auto exp_shape = PartialShape::dynamic();
+    auto allow_axis_skip = true;
+
+    auto param = make_shared<ov::op::v0::Parameter>(element::f32, p_shape);
+    auto axes_node = make_shared<ov::op::v0::Parameter>(element::i32, PartialShape{-1});
+    const auto squeeze = std::make_shared<op::v15::Squeeze>(param, axes_node, allow_axis_skip);
+
+    EXPECT_EQ(squeeze->get_element_type(), element::f32);
+    EXPECT_EQ(squeeze->get_output_partial_shape(0), exp_shape);
+    EXPECT_EQ(squeeze->get_allow_axis_skip(), allow_axis_skip);
+}
+
+}  // namespace
diff --git a/src/core/tests/visitors/op/squeeze.cpp b/src/core/tests/visitors/op/squeeze.cpp
index 6eb1674b26329a..be596a5fb1dc67 100644
--- a/src/core/tests/visitors/op/squeeze.cpp
+++ b/src/core/tests/visitors/op/squeeze.cpp
@@ -6,7 +6,16 @@
 
 #include "unary_ops.hpp"
 
+namespace v0 {
 using Types = ::testing::Types<UnaryOperatorType<ov::op::v0::Squeeze, ov::element::f32>,
                                UnaryOperatorType<ov::op::v0::Squeeze, ov::element::f16>>;
 
 INSTANTIATE_TYPED_TEST_SUITE_P(visitor_without_attribute, UnaryOperatorVisitor, Types, UnaryOperatorTypeName);
+}  // namespace v0
+
+namespace v15 {
+using Types = ::testing::Types<UnaryOperatorTypeWithAttribute<ov::op::v15::Squeeze, ov::element::f32>,
+                               UnaryOperatorTypeWithAttribute<ov::op::v15::Squeeze, ov::element::f16>>;
+
+INSTANTIATE_TYPED_TEST_SUITE_P(visitor_single_attribute, UnaryOperatorVisitor, Types, UnaryOperatorTypeName);
+}  // namespace v15
diff --git a/src/core/tests/visitors/op/unary_ops.hpp b/src/core/tests/visitors/op/unary_ops.hpp
index 3bef2429983e9f..6cc2afda62e253 100644
--- a/src/core/tests/visitors/op/unary_ops.hpp
+++ b/src/core/tests/visitors/op/unary_ops.hpp
@@ -9,12 +9,17 @@
 #include "openvino/op/parameter.hpp"
 #include "visitors/visitors.hpp"
 
-template <typename T, ov::element::Type_t ELEMENT_TYPE>
+template <typename T, ov::element::Type_t ELEMENT_TYPE, int ATTRIBUTES_COUNT = int{}>
 class UnaryOperatorType {
 public:
     using op_type = T;
     static constexpr ov::element::Type_t element_type = ELEMENT_TYPE;
+    static constexpr int expected_attr_count = ATTRIBUTES_COUNT;
 };
+
+template <typename T, ov::element::Type_t ELEMENT_TYPE>
+using UnaryOperatorTypeWithAttribute = UnaryOperatorType<T, ELEMENT_TYPE, 1>;
+
 template <typename T>
 class UnaryOperatorVisitor : public testing::Test {};
 
@@ -43,7 +48,7 @@ TYPED_TEST_P(UnaryOperatorVisitor, No_Attribute_4D) {
 
     EXPECT_NO_THROW(auto g_op_func = ov::as_type_ptr<OP_Type>(builder.create()));
 
-    const auto expected_attr_count = 0;
+    const auto expected_attr_count = TypeParam::expected_attr_count;
     EXPECT_EQ(builder.get_value_map_size(), expected_attr_count);
 }
 
diff --git a/src/plugins/intel_cpu/src/shape_inference/shape_inference.cpp b/src/plugins/intel_cpu/src/shape_inference/shape_inference.cpp
index bb2d5e5e84b267..1921169f83afd7 100644
--- a/src/plugins/intel_cpu/src/shape_inference/shape_inference.cpp
+++ b/src/plugins/intel_cpu/src/shape_inference/shape_inference.cpp
@@ -407,6 +407,7 @@ using IStaticShapeInferFactory =
 template <>
 const IStaticShapeInferFactory::TRegistry IStaticShapeInferFactory::registry{
     // opset15
+    _OV_OP_SHAPE_INFER_MASK_REG(op::v15::Squeeze, ShapeInferTA, util::bit::mask(1)),
     _OV_OP_SHAPE_INFER_MASK_REG(op::v15::SearchSorted, ShapeInferTA, util::bit::mask()),
     _OV_OP_SHAPE_INFER_MASK_REG(op::v15::StringTensorUnpack, ShapeInferTA, util::bit::mask(0)),
     _OV_OP_SHAPE_INFER_MASK_REG(op::v15::StringTensorPack, ShapeInferTA, util::bit::mask(0, 1)),
diff --git a/src/plugins/intel_cpu/tests/unit/shape_inference_test/squeeze_shape_inference_test.cpp b/src/plugins/intel_cpu/tests/unit/shape_inference_test/squeeze_shape_inference_test.cpp
index 69da74b10a2f45..5f790135780013 100644
--- a/src/plugins/intel_cpu/tests/unit/shape_inference_test/squeeze_shape_inference_test.cpp
+++ b/src/plugins/intel_cpu/tests/unit/shape_inference_test/squeeze_shape_inference_test.cpp
@@ -16,14 +16,16 @@ using namespace ov;
 using namespace ov::intel_cpu;
 using namespace testing;
 
-class SqueezeStaticShapeInferenceAssertTest : public OpStaticShapeInferenceTest<op::v0::Squeeze> {
+namespace v0 {
+
+class SqueezeV0StaticShapeInferenceAssertTest : public OpStaticShapeInferenceTest<op::v0::Squeeze> {
 protected:
     void SetUp() override {
         output_shapes = ShapeVector(1);
     }
 };
 
-TEST_F(SqueezeStaticShapeInferenceAssertTest, no_axes) {
+TEST_F(SqueezeV0StaticShapeInferenceAssertTest, no_axes) {
     const auto arg = std::make_shared<op::v0::Parameter>(element::f64, PartialShape{-1, -1});
     const auto axes = std::make_shared<op::v0::Parameter>(element::i64, PartialShape{1});
     const auto op = make_op(arg, axes);
@@ -35,7 +37,7 @@ TEST_F(SqueezeStaticShapeInferenceAssertTest, no_axes) {
                     HasSubstr("Check 'constant != nullptr'"));
 }
 
-TEST_F(SqueezeStaticShapeInferenceAssertTest, parameter_static_shape_axes_no_data) {
+TEST_F(SqueezeV0StaticShapeInferenceAssertTest, parameter_static_shape_axes_no_data) {
     const auto arg = std::make_shared<op::v0::Parameter>(element::f64, Shape{2, 1, 3, 1});
     const auto axes = std::make_shared<op::v0::Parameter>(element::i64, Shape{2});
     const auto op = make_op(arg, axes);
@@ -52,11 +54,11 @@ using TestParams = std::tuple<ShapeVector,           // Input shapes
                               StaticShape            // Expected shape
                               >;
 
-class SqueezeStaticShapeInferenceTest : public SqueezeStaticShapeInferenceAssertTest,
+class SqueezeV0StaticShapeInferenceTest : public SqueezeV0StaticShapeInferenceAssertTest,
                                         public WithParamInterface<TestParams> {
 protected:
     void SetUp() override {
-        SqueezeStaticShapeInferenceAssertTest::SetUp();
+        SqueezeV0StaticShapeInferenceAssertTest::SetUp();
         std::tie(input_shapes, axes, exp_shape) = GetParam();
 
         output_shapes = ShapeVector(1);
@@ -68,7 +70,7 @@ class SqueezeStaticShapeInferenceTest : public SqueezeStaticShapeInferenceAssert
 };
 
 INSTANTIATE_TEST_SUITE_P(1d_shapes,
-                         SqueezeStaticShapeInferenceTest,
+                         SqueezeV0StaticShapeInferenceTest,
                          Values(make_tuple(ShapeVector{{1}, {1}}, std::vector<int64_t>{-1}, StaticShape({})),
                                 make_tuple(ShapeVector{{6}, {1}}, std::vector<int64_t>{-1}, StaticShape({6})),
                                 make_tuple(ShapeVector{{1}, {1}}, std::vector<int64_t>{0}, StaticShape({}))),
@@ -76,7 +78,7 @@ INSTANTIATE_TEST_SUITE_P(1d_shapes,
 
 INSTANTIATE_TEST_SUITE_P(
     multi_dim_shapes,
-    SqueezeStaticShapeInferenceTest,
+    SqueezeV0StaticShapeInferenceTest,
     Values(make_tuple(ShapeVector{{1, 2, 3, 1}, {2}}, std::vector<int64_t>{0, 3}, StaticShape({2, 3})),
            make_tuple(ShapeVector{{2, 1, 1, 4}, {2}}, std::vector<int64_t>{2, 1}, StaticShape({2, 4})),
            make_tuple(ShapeVector{{2, 1, 1, 4, 1}, {2}}, std::vector<int64_t>{0, 1, -2, -1}, StaticShape({2, 1, 4})),
@@ -92,7 +94,7 @@ INSTANTIATE_TEST_SUITE_P(
 
 INSTANTIATE_TEST_SUITE_P(
     multi_dim_shapes_repeated_axis,
-    SqueezeStaticShapeInferenceTest,
+    SqueezeV0StaticShapeInferenceTest,
     Values(make_tuple(ShapeVector{{2, 1, 3}, {2}}, std::vector<int64_t>{1, 1}, StaticShape({2, 3})),
            make_tuple(ShapeVector{{3, 1, 2, 1}, {3}}, std::vector<int64_t>{1, -1, 1}, StaticShape({3, 2})),
            make_tuple(ShapeVector{{3, 1, 2, 1}, {3}}, std::vector<int64_t>{1, -1, 1, -1}, StaticShape({3, 2})),
@@ -100,7 +102,7 @@ INSTANTIATE_TEST_SUITE_P(
            make_tuple(ShapeVector{{2, 6, 7, 8, 1}, {2}}, std::vector<int64_t>{-1, -1}, StaticShape({2, 6, 7, 8}))),
     PrintToStringParamName());
 
-TEST_P(SqueezeStaticShapeInferenceTest, shape_inference_empty_const_map) {
+TEST_P(SqueezeV0StaticShapeInferenceTest, shape_inference_empty_const_map) {
     const auto axes_node = std::make_shared<op::v0::Constant>(element::i64, Shape{axes.size()}, axes);
     const auto op = make_op(arg, axes_node);
 
@@ -109,8 +111,8 @@ TEST_P(SqueezeStaticShapeInferenceTest, shape_inference_empty_const_map) {
     ASSERT_EQ(output_shapes.front(), exp_shape);
 }
 
-TEST_P(SqueezeStaticShapeInferenceTest, shape_inference_with_const_map) {
-    const auto axes_node = std::make_shared<op::v0::Parameter>(element::i64, Shape{1});
+TEST_P(SqueezeV0StaticShapeInferenceTest, shape_inference_with_const_map) {
+    const auto axes_node = std::make_shared<op::v0::Parameter>(element::i64, ov::PartialShape::dynamic());
     const auto op = make_op(arg, axes_node);
 
     const auto axes_tensor = axes.empty() ? ov::Tensor(element::i64, ov::Shape{axes.size()})
@@ -121,3 +123,115 @@ TEST_P(SqueezeStaticShapeInferenceTest, shape_inference_with_const_map) {
 
     ASSERT_EQ(output_shapes.front(), exp_shape);
 }
+
+}   // namespace v0
+
+namespace v15 {
+
+class SqueezeV15StaticShapeInferenceAssertTest : public OpStaticShapeInferenceTest<op::v15::Squeeze> {
+protected:
+    void SetUp() override {
+        output_shapes = ShapeVector(1);
+    }
+};
+
+TEST_F(SqueezeV15StaticShapeInferenceAssertTest, no_axes) {
+    const auto arg = std::make_shared<op::v0::Parameter>(element::f64, PartialShape{-1, -1});
+    const auto axes = std::make_shared<op::v0::Parameter>(element::i64, PartialShape{1});
+    const auto op = make_op(arg, axes);
+
+    input_shapes = ShapeVector{{5, 6}, axes->get_shape()};
+
+    OV_EXPECT_THROW(shape_inference(op.get(), input_shapes),
+                    NodeValidationFailure,
+                    HasSubstr("Check 'constant != nullptr'"));
+}
+
+TEST_F(SqueezeV15StaticShapeInferenceAssertTest, parameter_static_shape_axes_no_data) {
+    const auto arg = std::make_shared<op::v0::Parameter>(element::f64, Shape{2, 1, 3, 1});
+    const auto axes = std::make_shared<op::v0::Parameter>(element::i64, Shape{2});
+    const auto op = make_op(arg, axes);
+
+    input_shapes = ShapeVector{arg->get_shape(), axes->get_shape()};
+
+    OV_EXPECT_THROW(shape_inference(op.get(), input_shapes),
+                    NodeValidationFailure,
+                    HasSubstr("Check 'constant != nullptr'"));
+}
+
+using TestParams = std::tuple<ShapeVector,           // Input shapes
+                              std::vector<int64_t>,  // Squeeze axes
+                              StaticShape            // Expected shape
+                              >;
+
+class SqueezeV15StaticShapeInferenceTest : public SqueezeV15StaticShapeInferenceAssertTest,
+                                        public WithParamInterface<TestParams> {
+protected:
+    void SetUp() override {
+        SqueezeV15StaticShapeInferenceAssertTest::SetUp();
+        std::tie(input_shapes, axes, exp_shape) = GetParam();
+
+        output_shapes = ShapeVector(1);
+        arg = std::make_shared<op::v0::Parameter>(element::f32, input_shapes.front().get_shape());
+    }
+
+    std::vector<int64_t> axes;
+    std::shared_ptr<op::v0::Parameter> arg;
+};
+
+INSTANTIATE_TEST_SUITE_P(1d_shapes,
+                         SqueezeV15StaticShapeInferenceTest,
+                         Values(make_tuple(ShapeVector{{1}, {1}}, std::vector<int64_t>{-1}, StaticShape({})),
+                                make_tuple(ShapeVector{{6}, {1}}, std::vector<int64_t>{-1}, StaticShape({6})),
+                                make_tuple(ShapeVector{{1}, {1}}, std::vector<int64_t>{0}, StaticShape({}))),
+                         PrintToStringParamName());
+
+INSTANTIATE_TEST_SUITE_P(
+    multi_dim_shapes,
+    SqueezeV15StaticShapeInferenceTest,
+    Values(make_tuple(ShapeVector{{1, 2, 3, 1}, {2}}, std::vector<int64_t>{0, 3}, StaticShape({2, 3})),
+           make_tuple(ShapeVector{{2, 1, 1, 4}, {2}}, std::vector<int64_t>{2, 1}, StaticShape({2, 4})),
+           make_tuple(ShapeVector{{2, 1, 1, 4, 1}, {2}}, std::vector<int64_t>{0, 1, -2, -1}, StaticShape({2, 1, 4})),
+           make_tuple(ShapeVector{{1, 3, 1, 2, 1}, {3}}, std::vector<int64_t>{0, 2, 4}, StaticShape({3, 2})),
+           make_tuple(ShapeVector{{1, 3, 1, 2, 1}, {3}}, std::vector<int64_t>{4, 2, 0}, StaticShape({3, 2})),
+           make_tuple(ShapeVector{{1, 3, 1, 2, 1}, {3}}, std::vector<int64_t>{2, 0, 4}, StaticShape({3, 2})),
+           make_tuple(ShapeVector{{10, 1, 0, 1, 3, 1, 1}, {4}},
+                      std::vector<int64_t>{1, -1, 3, -2},
+                      StaticShape({10, 0, 3})),
+           make_tuple(ShapeVector{{10, 1, 0, 1, 3, 1, 1}, {}}, std::vector<int64_t>{}, StaticShape({10, 0, 3})),
+           make_tuple(ShapeVector{{2, 1, 7, 8, 3}, {1}}, std::vector<int64_t>{1}, StaticShape({2, 7, 8, 3}))),
+    PrintToStringParamName());
+
+INSTANTIATE_TEST_SUITE_P(
+    multi_dim_shapes_repeated_axis,
+    SqueezeV15StaticShapeInferenceTest,
+    Values(make_tuple(ShapeVector{{2, 1, 3}, {2}}, std::vector<int64_t>{1, 1}, StaticShape({2, 3})),
+           make_tuple(ShapeVector{{3, 1, 2, 1}, {3}}, std::vector<int64_t>{1, -1, 1}, StaticShape({3, 2})),
+           make_tuple(ShapeVector{{3, 1, 2, 1}, {3}}, std::vector<int64_t>{1, -1, 1, -1}, StaticShape({3, 2})),
+           make_tuple(ShapeVector{{1, 3, 1, 2, 1}, {3}}, std::vector<int64_t>{2, -1, 2, -1, 0}, StaticShape({3, 2})),
+           make_tuple(ShapeVector{{2, 6, 7, 8, 1}, {2}}, std::vector<int64_t>{-1, -1}, StaticShape({2, 6, 7, 8}))),
+    PrintToStringParamName());
+
+TEST_P(SqueezeV15StaticShapeInferenceTest, shape_inference_empty_const_map) {
+    const auto axes_node = std::make_shared<op::v0::Constant>(element::i64, Shape{axes.size()}, axes);
+    const auto op = make_op(arg, axes_node);
+
+    output_shapes = shape_inference(op.get(), input_shapes);
+
+    ASSERT_EQ(output_shapes.front(), exp_shape);
+}
+
+TEST_P(SqueezeV15StaticShapeInferenceTest, shape_inference_with_const_map) {
+    const auto axes_node = std::make_shared<op::v0::Parameter>(element::i64, ov::PartialShape::dynamic());
+    const auto op = make_op(arg, axes_node);
+
+    const auto axes_tensor = axes.empty() ? ov::Tensor(element::i64, ov::Shape{axes.size()})
+                                          : ov::Tensor(element::i64, ov::Shape{axes.size()}, axes.data());
+    const auto constant_data = std::unordered_map<size_t, ov::Tensor>{{1, axes_tensor}};
+
+    output_shapes = shape_inference(op.get(), input_shapes, constant_data);
+
+    ASSERT_EQ(output_shapes.front(), exp_shape);
+}
+
+}   // namespace v15
diff --git a/src/plugins/template/tests/functional/op_reference/squeeze.cpp b/src/plugins/template/tests/functional/op_reference/squeeze.cpp
index 8bf1902c403a1b..e397c7c403cec8 100644
--- a/src/plugins/template/tests/functional/op_reference/squeeze.cpp
+++ b/src/plugins/template/tests/functional/op_reference/squeeze.cpp
@@ -63,7 +63,7 @@ struct SqueezeParams {
     bool m_axes_node;
 };
 
-class ReferenceSqueezeLayerTest : public testing::TestWithParam<SqueezeParams>, public CommonReferenceTest {
+class ReferenceSqueezeLayerTestBase : public testing::TestWithParam<SqueezeParams>, public CommonReferenceTest {
 public:
     void SetUp() override {
         const auto params = GetParam();
@@ -90,7 +90,12 @@ class ReferenceSqueezeLayerTest : public testing::TestWithParam<SqueezeParams>,
     }
 
 private:
-    static std::shared_ptr<Model> CreateFunction(const SqueezeParams& params) {
+    virtual std::shared_ptr<Model> CreateFunction(const SqueezeParams&) = 0;
+};
+
+class ReferenceSqueezeLayerTest : public ReferenceSqueezeLayerTestBase {
+private:
+    std::shared_ptr<Model> CreateFunction(const SqueezeParams& params) override {
         const auto in = std::make_shared<op::v0::Parameter>(params.m_input_type, params.m_input_shape);
         std::shared_ptr<op::v0::Constant> axes_node = NULL;
         std::shared_ptr<op::v0::Squeeze> squeeze = NULL;
@@ -180,4 +185,58 @@ INSTANTIATE_TEST_SUITE_P(smoke_Squeeze_With_Hardcoded_Refs,
                          ::testing::ValuesIn(generateCombinedParamsForSqueeze()),
                          ReferenceSqueezeLayerTest::getTestCaseName);
 
+class ReferenceSqueezeV15LayerTest : public ReferenceSqueezeLayerTestBase {
+private:
+    std::shared_ptr<Model> CreateFunction(const SqueezeParams& params) override {
+        const auto in = std::make_shared<op::v0::Parameter>(params.m_input_type, params.m_input_shape);
+        std::shared_ptr<op::v0::Constant> axes_node = NULL;
+        std::shared_ptr<op::v15::Squeeze> squeeze = NULL;
+        if (params.m_axes_node) {
+            axes_node =
+                std::make_shared<op::v0::Constant>(params.m_axes_type, params.m_axes_shape, params.m_axes_value.data());
+            squeeze = std::make_shared<op::v15::Squeeze>(in, axes_node);
+        } else {
+            squeeze = std::make_shared<op::v15::Squeeze>(in);
+        }
+
+        return std::make_shared<ov::Model>(squeeze, ParameterVector{in});
+    }
+};
+
+TEST_P(ReferenceSqueezeV15LayerTest, CompareWithHardcodedRefs) {
+    Exec();
+}
+
+INSTANTIATE_TEST_SUITE_P(smoke_Squeeze_With_Hardcoded_Refs,
+                         ReferenceSqueezeV15LayerTest,
+                         ::testing::ValuesIn(generateCombinedParamsForSqueeze()),
+                         ReferenceSqueezeV15LayerTest::getTestCaseName);
+
+class ReferenceSqueezeV15AttributeSetLayerTest : public ReferenceSqueezeLayerTestBase {
+private:
+    std::shared_ptr<Model> CreateFunction(const SqueezeParams& params) override {
+        const auto in = std::make_shared<op::v0::Parameter>(params.m_input_type, params.m_input_shape);
+        std::shared_ptr<op::v0::Constant> axes_node = NULL;
+        std::shared_ptr<op::v15::Squeeze> squeeze = NULL;
+        if (params.m_axes_node) {
+            axes_node =
+                std::make_shared<op::v0::Constant>(params.m_axes_type, params.m_axes_shape, params.m_axes_value.data());
+            squeeze = std::make_shared<op::v15::Squeeze>(in, axes_node, true);
+        } else {
+            squeeze = std::make_shared<op::v15::Squeeze>(in, true);
+        }
+
+        return std::make_shared<ov::Model>(squeeze, ParameterVector{in});
+    }
+};
+
+TEST_P(ReferenceSqueezeV15AttributeSetLayerTest, CompareWithHardcodedRefs) {
+    Exec();
+}
+
+INSTANTIATE_TEST_SUITE_P(smoke_Squeeze_With_Hardcoded_Refs,
+                         ReferenceSqueezeV15AttributeSetLayerTest,
+                         ::testing::ValuesIn(generateCombinedParamsForSqueeze()),
+                         ReferenceSqueezeV15AttributeSetLayerTest::getTestCaseName);
+
 }  // namespace
diff --git a/src/tests/functional/plugin/conformance/test_runner/op_conformance_runner/src/op_impl_check/single_op_graph.cpp b/src/tests/functional/plugin/conformance/test_runner/op_conformance_runner/src/op_impl_check/single_op_graph.cpp
index f38427b7b192ed..bcb259cd49b60f 100644
--- a/src/tests/functional/plugin/conformance/test_runner/op_conformance_runner/src/op_impl_check/single_op_graph.cpp
+++ b/src/tests/functional/plugin/conformance/test_runner/op_conformance_runner/src/op_impl_check/single_op_graph.cpp
@@ -1193,7 +1193,15 @@ std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::Squeeze> &
     const auto axes = std::make_shared<ov::op::v0::Constant>(ov::element::i64, ov::Shape{2}, std::vector<int64_t>{0, 2});
     auto Node = std::make_shared<ov::op::v0::Squeeze>(params.at(0), axes);
     ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
-    return std::make_shared<ov::Model>(results, params, "SqueezeGraph");
+    return std::make_shared<ov::Model>(results, params, "SqueezeV0Graph");
+}
+
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v15::Squeeze> &node) {
+    ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{{1, 4, 1, 1, 2}})};
+    const auto axes = std::make_shared<ov::op::v0::Constant>(ov::element::i64, ov::Shape{2}, std::vector<int64_t>{0, 2});
+    auto Node = std::make_shared<ov::op::v15::Squeeze>(params.at(0), axes);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(Node)};
+    return std::make_shared<ov::Model>(results, params, "SqueezeV15Graph");
 }
 
 std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v1::StridedSlice> &node) {
diff --git a/src/tests/test_utils/common_test_utils/include/common_test_utils/type_prop.hpp b/src/tests/test_utils/common_test_utils/include/common_test_utils/type_prop.hpp
index 2a953ad27740e6..e097a3ab957d13 100644
--- a/src/tests/test_utils/common_test_utils/include/common_test_utils/type_prop.hpp
+++ b/src/tests/test_utils/common_test_utils/include/common_test_utils/type_prop.hpp
@@ -7,7 +7,11 @@
 #include "gmock/gmock.h"
 #include "openvino/core/dimension.hpp"
 #include "openvino/core/partial_shape.hpp"
+#include "openvino/op/constant.hpp"
+#include "openvino/op/gather.hpp"
 #include "openvino/op/parameter.hpp"
+#include "openvino/op/shape_of.hpp"
+#include "openvino/op/unsqueeze.hpp"
 
 #define EXPECT_HAS_SUBSTRING(haystack, needle) EXPECT_PRED_FORMAT2(testing::IsSubstring, needle, haystack)
 
@@ -56,6 +60,23 @@ class UnSqueezeBoundTest : public testing::WithParamInterface<std::tuple<ov::Par
         param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{1});
     }
 
+    template <typename T>
+    auto create_squeeze(ov::PartialShape symboled_shape) -> std::shared_ptr<T> {
+        constexpr auto et = ov::element::i64;
+        const auto symboled_param = std::make_shared<ov::op::v0::Parameter>(et, symboled_shape);
+        const auto symboled_shape_of = std::make_shared<ov::op::v0::ShapeOf>(symboled_param);
+
+        const auto zero = std::vector<int64_t>{0};
+        const auto axis = std::make_shared<ov::op::v0::Constant>(et, ov::Shape{}, zero);
+        const auto indices = std::make_shared<ov::op::v0::Constant>(et, ov::Shape{}, zero);
+        const auto gather = std::make_shared<ov::op::v7::Gather>(symboled_shape_of, indices, axis);
+        const auto axis_1 = std::make_shared<ov::op::v0::Constant>(et, ov::Shape{2}, std::vector<int64_t>{0, 1});
+        const auto unsqueeze = std::make_shared<ov::op::v0::Unsqueeze>(gather, axis_1);
+        const auto squeeze = std::make_shared<T>(unsqueeze, axis);
+
+        return squeeze;
+    }
+
     ov::TensorSymbol in_symbols;
 };