diff --git a/inference-engine/src/legacy_api/src/ie_cnn_layer_builder_ngraph.cpp b/inference-engine/src/legacy_api/src/ie_cnn_layer_builder_ngraph.cpp
index dbf0106b3f2..50c68108e39 100644
--- a/inference-engine/src/legacy_api/src/ie_cnn_layer_builder_ngraph.cpp
+++ b/inference-engine/src/legacy_api/src/ie_cnn_layer_builder_ngraph.cpp
@@ -1147,14 +1147,6 @@ CNNLayer::Ptr NodeConverter<ngraph::op::ReverseSequence>::createLayer(const std:
     return res;
 }
 
-template <>
-CNNLayer::Ptr NodeConverter<ngraph::op::Reshape>::createLayer(const std::shared_ptr<ngraph::Node>& layer) const {
-    LayerParams params = {layer->get_friendly_name(), "Reshape",
-                          details::convertPrecision(layer->get_output_element_type(0))};
-    auto res = std::make_shared<InferenceEngine::ReshapeLayer>(params);
-    return res;
-}
-
 template <>
 CNNLayer::Ptr NodeConverter<ngraph::op::ShapeOf>::createLayer(const std::shared_ptr<ngraph::Node>& layer) const {
     LayerParams params = {layer->get_friendly_name(), "ShapeOf",
diff --git a/ngraph/core/builder/include/ngraph/builder/reshape.hpp b/ngraph/core/builder/include/ngraph/builder/reshape.hpp
index 58330fe5590..c4e7f0d22e8 100644
--- a/ngraph/core/builder/include/ngraph/builder/reshape.hpp
+++ b/ngraph/core/builder/include/ngraph/builder/reshape.hpp
@@ -46,7 +46,7 @@ namespace ngraph
             std::shared_ptr<Node> reorder_axes(const Output<Node>& value,
                                                std::vector<size_t> axes_order = {});
 
-            /// \brief      Return transposed vlaue (with axes in reversed order).
+            /// \brief      Return transposed value (with axes in reversed order).
             ///
             /// \param      Value to transpose.
             ///
diff --git a/ngraph/core/builder/src/builder/autobroadcast.cpp b/ngraph/core/builder/src/builder/autobroadcast.cpp
index 3a74ec53af7..9ac059f47c7 100644
--- a/ngraph/core/builder/src/builder/autobroadcast.cpp
+++ b/ngraph/core/builder/src/builder/autobroadcast.cpp
@@ -233,8 +233,7 @@ namespace ngraph
             auto trimmed_value = value;
             if (value_shape != trimmed_value_shape)
             {
-                trimmed_value = make_shared<op::Reshape>(
-                    value, get_default_order(value_shape), trimmed_value_shape);
+                trimmed_value = builder::opset1::reshape(value, trimmed_value_shape);
             }
 
             auto shape_const =
diff --git a/ngraph/core/builder/src/builder/matmul_factory.cpp b/ngraph/core/builder/src/builder/matmul_factory.cpp
index 753287cccda..92df40a9210 100644
--- a/ngraph/core/builder/src/builder/matmul_factory.cpp
+++ b/ngraph/core/builder/src/builder/matmul_factory.cpp
@@ -149,8 +149,7 @@ OutputVector builder::MatmulFactory::make_matmul_op()
         Shape result_shape(next(begin(shape)), end(shape));
         result_shape.insert(
             begin(result_shape), begin(left_shape), next(begin(left_shape), left_shape.size() - 2));
-        return {make_shared<op::Reshape>(result, get_default_order(shape.size()), result_shape)
-                    ->add_provenance_group_members_above(m_inputs)};
+        return {builder::opset1::reshape(result, result_shape)};
     }
 }
 
diff --git a/ngraph/core/include/ngraph/op/op_version_tbl.hpp b/ngraph/core/include/ngraph/op/op_version_tbl.hpp
index 52500720676..c88bf6cadec 100644
--- a/ngraph/core/include/ngraph/op/op_version_tbl.hpp
+++ b/ngraph/core/include/ngraph/op/op_version_tbl.hpp
@@ -145,7 +145,6 @@ NGRAPH_OP(ReduceSum, ngraph::op::v1, 1)
 NGRAPH_OP(RegionYolo, ngraph::op::v0, 0)
 NGRAPH_OP(Relu, ngraph::op::v0, 0)
 NGRAPH_OP(ReorgYolo, ngraph::op::v0, 0)
-NGRAPH_OP(Reshape, ngraph::op::v0, 0)
 NGRAPH_OP(Reshape, ngraph::op::v1, 1)
 NGRAPH_OP(Result, ngraph::op::v0, 0)
 NGRAPH_OP(Reverse, ngraph::op::v1, 1)
diff --git a/ngraph/core/include/ngraph/op/reshape.hpp b/ngraph/core/include/ngraph/op/reshape.hpp
index 049dde988c4..b24a8713f80 100644
--- a/ngraph/core/include/ngraph/op/reshape.hpp
+++ b/ngraph/core/include/ngraph/op/reshape.hpp
@@ -25,96 +25,6 @@ namespace ngraph
 {
     namespace op
     {
-        namespace v0
-        {
-            // clang-format off
-        /// \brief Tensor reshape operation.
-        ///
-        /// "Converts" an input tensor into a new shape with the same number of elements.
-        ///
-        /// Given that the input tensor has shape \f$[d_1,\dots,d_n]\f$, the output may have any
-        /// shape \f$[d'_1,\dots,d'_m]\f$ such that
-        /// \f$\Pi_{0 \leq i \lt n}(d_i) = \Pi_{0 \leq i \lt m}(d'_i)\f$. For example, a
-        /// \f$3\times{}4\f$ matrix can be reshaped into a 3-tensor of shape
-        /// \f$3\times{}2\times{}2\f$, a matrix of shape \f$6\times{}2\f$, or a vector of size
-        /// \f$12\f$, but not, for example, a matrix of size \f$4\times{}4\f$.
-        ///
-        /// The parameter `input_order` indicates the order in which to "walk" over the input axes.
-        /// Given a tensor of shape \f$(d_1,\dots,d_n)\f$, an input order of
-        /// \f$(a_0, a_1, \dots, a_{n-1})\f$ results in the coordinate for axis \f$a_{n-1}\f$ being
-        /// varied most frequently, followed by axis \f$a-2\f$, and so on down to \f$a_0\f$.
-        ///
-        /// (TODO: example.)
-        ///
-        /// ## Parameters
-        ///
-        /// |                | Description                                                |
-        /// | -------------- | ---------------------------------------------------------- |
-        /// | `input_order`  | The order in which to walk over the input axes.            |
-        /// | `output_shape` | The shape \f$[d'_1,\dots,d'_m]\f$ for the reshaped tensor. |
-        ///
-        /// ## Inputs
-        ///
-        /// |       | Type                              | Description                                                                                                  |
-        /// | ----- | --------------------------------- | ------------------------------------------------------------------------------------------------------------ |
-        /// | `arg` | \f$E[d_1,\dots,d_n]~(n \geq 0)\f$ | An input tensor of any type and shape, as long as the product of \f$d_i\f$ equals the product of \f$d'_i\f$. |
-        ///
-        /// ## Output
-        ///
-        /// | Type                     | Description                                                                                            |
-        /// | ------------------------ | ------------------------------------------------------------------------------------------------------ |
-        /// | \f$E[d'_1,\dots,d'_m]\f$ | The tensor \f$T\f$, where \f$T\f$ is the input tensor with its elements rearranged as described above. |
-            // clang-format on
-            class NGRAPH_DEPRECATED(
-                "This operation is deprecated and will be removed soon. "
-                "Use v1::Reshape instead of it.") NGRAPH_API Reshape : public Op
-            {
-                NGRAPH_SUPPRESS_DEPRECATED_START
-            public:
-                static constexpr NodeTypeInfo type_info{"Reshape", 0};
-                const NodeTypeInfo& get_type_info() const override { return type_info; }
-                /// \brief Constructs a reshape operation.
-                Reshape() = default;
-                /// \brief Constructs a reshape operation.
-                ///
-                /// \param arg The tensor to be reshaped.
-                /// \param input_order The order in which to iterate over input axes. This must be a
-                ///                    permutation of the sequence \f$(0,\dots,n-1)\f$ where \f$n\f$
-                ///                    is
-                ///                    the rank of the input tensor.
-                /// \param output_shape The output shape. If the input shape is
-                ///                     \f$(a_0,\dots,a_{k-1})\f$ then the output shape must
-                ///                     be of the form \f$(b_0,\dots,b_{j-1})\f$ where
-                ///                     \f$\Pi(a_i) = \Pi(b_i)\f$.
-                Reshape(const Output<Node>& arg,
-                        const AxisVector& input_order,
-                        const Shape& output_shape);
-
-                void validate_and_infer_types() override;
-
-                virtual std::shared_ptr<Node>
-                    clone_with_new_inputs(const OutputVector& new_args) const override;
-                bool visit_attributes(AttributeVisitor& visitor) override;
-
-                /// \return The order in which to iterate over input axes.
-                const AxisVector& get_input_order() const { return m_input_order; }
-                void set_input_order(const AxisVector& input_order) { m_input_order = input_order; }
-                /// \return The shape of the output tensor.
-                const Shape& get_reshape_output_shape() const { return m_output_shape; }
-                void set_output_shape(const Shape& output_shape) { m_output_shape = output_shape; }
-                bool get_is_transpose() const { return m_is_transpose; }
-                void set_is_transpose(bool is_transpose) { m_is_transpose = is_transpose; }
-                bool evaluate(const HostTensorVector& outputs,
-                              const HostTensorVector& inputs) const override;
-
-            protected:
-                AxisVector m_input_order;
-                Shape m_output_shape;
-                bool m_is_transpose{false};
-                NGRAPH_SUPPRESS_DEPRECATED_END
-            };
-        }
-
         namespace v1
         {
             /// \brief Tensor dynamic reshape operation.
@@ -131,16 +41,19 @@ namespace ngraph
                 ///        transpose.
                 ///
                 /// \param arg The tensor to be reshaped.
-                /// \param pattern The node that defines output shape pattern.
+                /// \param shape_pattern The node that defines output shape shape_pattern.
                 ///        If the input shape is \f$(a_0,\dots,a_{k-1})\f$ then the output shape
                 ///        must
                 ///        be of the form \f$(b_0,\dots,b_{j-1})\f$ where \f$\Pi(a_i) = \Pi(b_i)\f$.
                 ///        A value of -1 is allowed for at most one dimension, in which case the
                 ///        dimension size is inferred based on element count of input tensor.
-                /// \param special_zero Treats zeros in `pattern` as wildcard flags indicating a
+                /// \param special_zero Treats zeros in `shape_pattern` as wildcard flags indicating
+                /// a
                 ///        copy from input shape at the same index.
                 ///
-                Reshape(const Output<Node>& arg, const Output<Node>& pattern, bool special_zero);
+                Reshape(const Output<Node>& arg,
+                        const Output<Node>& shape_pattern,
+                        bool special_zero);
 
                 bool visit_attributes(AttributeVisitor& visitor) override;
                 void validate_and_infer_types() override;
@@ -160,8 +73,5 @@ namespace ngraph
                 bool m_special_zero;
             };
         }
-        NGRAPH_SUPPRESS_DEPRECATED_START
-        using v0::Reshape;
-        NGRAPH_SUPPRESS_DEPRECATED_END
     }
 }
diff --git a/ngraph/core/src/op/dot.cpp b/ngraph/core/src/op/dot.cpp
index fa2e1cde348..825aed116fa 100644
--- a/ngraph/core/src/op/dot.cpp
+++ b/ngraph/core/src/op/dot.cpp
@@ -157,28 +157,6 @@ void op::Dot::validate_and_infer_types()
     set_output_type(0, result_et, result_shape);
 }
 
-shared_ptr<op::Reshape> make_reshape_axes_to_front(const Output<Node>& n,
-                                                   const Shape& front_shape,
-                                                   const Shape& back_shape)
-{
-    AxisVector input_order;
-    Shape output_shape;
-
-    for (size_t i = 0; i < back_shape.size(); i++)
-    {
-        input_order.push_back(front_shape.size() + i);
-        output_shape.push_back(back_shape[i]);
-    }
-
-    for (size_t i = 0; i < front_shape.size(); i++)
-    {
-        input_order.push_back(i);
-        output_shape.push_back(front_shape[i]);
-    }
-
-    return make_shared<op::Reshape>(n, input_order, output_shape);
-}
-
 shared_ptr<Node> op::Dot::get_default_value() const
 {
     return ngraph::make_constant_from_string("0", get_element_type(), get_shape());
diff --git a/ngraph/core/src/op/reshape.cpp b/ngraph/core/src/op/reshape.cpp
index 9368020bad4..ff8e580c98b 100644
--- a/ngraph/core/src/op/reshape.cpp
+++ b/ngraph/core/src/op/reshape.cpp
@@ -24,8 +24,6 @@
 #include "ngraph/runtime/opt_kernel/reshape.hpp"
 #include "ngraph/runtime/reference/reshape.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
@@ -45,126 +43,23 @@ namespace
     }
 
     template <element::Type_t ET>
-    void compute_output_shape(const HostTensorPtr& pattern, Shape& output_shape)
+    void compute_output_shape(const HostTensorPtr& shape_pattern,
+                              std::vector<int64_t>& output_shape)
     {
         using T = typename element_type_traits<ET>::value_type;
-        T* pattern_ptr = pattern->get_data_ptr<ET>();
-        size_t output_rank = pattern->get_shape()[0];
+        T* shape_pattern_ptr = shape_pattern->get_data_ptr<ET>();
+        size_t output_rank = shape_pattern->get_shape()[0];
         for (int i = 0; i < output_rank; i++)
         {
-            output_shape.push_back(pattern_ptr[i]);
+            output_shape.push_back(shape_pattern_ptr[i]);
         }
     }
 }
 
-constexpr NodeTypeInfo op::Reshape::type_info;
-
-op::Reshape::Reshape(const Output<Node>& arg,
-                     const AxisVector& input_order,
-                     const Shape& output_shape)
-    : Op({arg})
-    , m_input_order(input_order)
-    , m_output_shape(output_shape)
-{
-    constructor_validate_and_infer_types();
-}
-
-void op::Reshape::validate_and_infer_types()
-{
-    auto& input_shape = get_input_partial_shape(0);
-    auto input_rank = input_shape.rank();
-
-    // Check that the input axis order is a permutation of (0,...,n-1) for some n.
-    for (size_t i = 0; i < m_input_order.size(); i++)
-    {
-        NODE_VALIDATION_CHECK(
-            this,
-            find(begin(m_input_order), end(m_input_order), i) != end(m_input_order),
-            "Input axis order is not a permutation of argument's axis indices (axis order: ",
-            m_input_order,
-            ", argument shape: ",
-            input_shape,
-            ").");
-    }
-
-    // TODO(amprocte): should be possible to move around unknown dims in the input shape.
-    if (input_rank.is_static())
-    {
-        NODE_VALIDATION_CHECK(
-            this,
-            m_input_order.size() == input_rank.get_length(),
-            "Input axis order is not a permutation of argument's axis indices (axis order: ",
-            m_input_order,
-            ", argument shape: ",
-            input_shape,
-            ").");
-
-        for (size_t i = 0; i < input_rank.get_length(); i++)
-        {
-            auto it = find(begin(m_input_order), end(m_input_order), i);
-            NODE_VALIDATION_CHECK(
-                this,
-                it != end(m_input_order),
-                "Input axis order is not a permutation of argument's axis indices (axis order: ",
-                m_input_order,
-                ", argument shape: ",
-                input_shape,
-                ").");
-        }
-
-        // TODO(amprocte): make a partial_shape_size() analogous to shape_size().
-        Dimension input_shape_product = 1;
-        for (size_t i = 0; i < input_rank.get_length(); i++)
-        {
-            input_shape_product *= input_shape[i];
-        }
-
-        if (input_shape_product.is_static())
-        {
-            NODE_VALIDATION_CHECK(
-                this,
-                input_shape_product.get_length() == shape_size(m_output_shape),
-                "Product of output shape dimensions does not match product of argument shape "
-                "dimensions ",
-                "(output shape: ",
-                m_output_shape,
-                ", argument shape: ",
-                input_shape,
-                ").");
-        }
-    }
-
-    if (!std::is_sorted(m_input_order.begin(), m_input_order.end()))
-    {
-        m_is_transpose = true;
-    }
-    set_output_type(0, get_input_element_type(0), m_output_shape);
-}
-
-shared_ptr<Node> op::Reshape::clone_with_new_inputs(const OutputVector& new_args) const
-{
-    check_new_args_count(this, new_args);
-    return make_shared<Reshape>(new_args.at(0), m_input_order, m_output_shape);
-}
-
-bool op::Reshape::visit_attributes(AttributeVisitor& visitor)
-{
-    visitor.on_attribute("input_order", m_input_order);
-    visitor.on_attribute("output_shape", m_output_shape);
-    return true;
-}
-
-bool op::v0::Reshape::evaluate(const HostTensorVector& outputs,
-                               const HostTensorVector& inputs) const
-{
-    OV_ITT_SCOPED_TASK(itt::domains::nGraphOp, "op::v0::Reshape::evaluate");
-    return evaluate_reshape(inputs[0], outputs[0], get_input_order());
-}
-
 NGRAPH_RTTI_DEFINITION(op::v1::Reshape, "Reshape", 1);
 
-op::v1::Reshape::Reshape(const Output<Node>& arg, const Output<Node>& pattern, bool zero_flag)
-    : Op({arg, pattern})
+op::v1::Reshape::Reshape(const Output<Node>& arg, const Output<Node>& shape_pattern, bool zero_flag)
+    : Op({arg, shape_pattern})
     , m_special_zero(zero_flag)
 {
     constructor_validate_and_infer_types();
@@ -178,20 +73,21 @@ bool op::v1::Reshape::visit_attributes(AttributeVisitor& visitor)
 
 void op::v1::Reshape::validate_and_infer_types()
 {
-    auto pattern_et = get_input_element_type(1);
+    auto shape_pattern_et = get_input_element_type(1);
     // check data types
     NODE_VALIDATION_CHECK(
-        this, pattern_et.is_integral_number(), "Pattern must be an integral number.");
+        this, shape_pattern_et.is_integral_number(), "Shape pattern must be an integral number.");
 
     // check shapes
     const PartialShape& input_pshape = get_input_partial_shape(0);
-    const PartialShape& pattern_shape = get_input_partial_shape(1);
+    const PartialShape& shape_pattern_shape = get_input_partial_shape(1);
     NODE_VALIDATION_CHECK(this,
-                          pattern_shape.rank().compatible(1),
+                          shape_pattern_shape.rank().compatible(1),
                           "Pattern shape must have rank 1, got ",
-                          pattern_shape.rank(),
+                          shape_pattern_shape.rank(),
                           ".");
-    Rank output_rank = pattern_shape.rank().is_dynamic() ? Rank::dynamic() : pattern_shape[0];
+    Rank output_rank =
+        shape_pattern_shape.rank().is_dynamic() ? Rank::dynamic() : shape_pattern_shape[0];
 
     set_input_is_relevant_to_shape(1);
 
@@ -339,7 +235,7 @@ bool op::v1::Reshape::evaluate(const HostTensorVector& outputs,
     // infer and set output shape if the output shape contain -1
     // and zero value dimension
     size_t output_rank = inputs[1]->get_shape()[0];
-    Shape out_shape_val;
+    std::vector<int64_t> out_shape_val;
 
     switch (inputs[1]->get_element_type())
     {
@@ -367,7 +263,7 @@ bool op::v1::Reshape::evaluate(const HostTensorVector& outputs,
     case element::Type_t::u64:
         compute_output_shape<element::Type_t::u64>(inputs[1], out_shape_val);
         break;
-    default: throw ngraph_error("pattern element type is not integral data type");
+    default: throw ngraph_error("shape_pattern element type is not integral data type");
     }
 
     NODE_VALIDATION_CHECK(
@@ -382,9 +278,10 @@ bool op::v1::Reshape::evaluate(const HostTensorVector& outputs,
     NODE_VALIDATION_CHECK(
         this, negative_dims <= 1, "More than one dimension has size of -1 (", negative_dims, ")");
 
+    Shape output_shape;
+    std::copy(out_shape_val.begin(), out_shape_val.end(), std::back_inserter(output_shape));
     if (!(zero_dims && m_special_zero) && !negative_dims)
     {
-        auto output_shape = out_shape_val;
         if (get_input_partial_shape(0).is_static())
         {
             NODE_VALIDATION_CHECK(this,
@@ -398,7 +295,6 @@ bool op::v1::Reshape::evaluate(const HostTensorVector& outputs,
     }
     else
     {
-        Shape output_shape = out_shape_val;
         size_t output_elements = 1;
         int negative_dim = -1;
 
@@ -482,4 +378,4 @@ bool op::v1::Reshape::constant_fold(OutputVector& output_values, const OutputVec
         return true;
     }
     return false;
-}
\ No newline at end of file
+}
diff --git a/ngraph/core/src/op/squeeze.cpp b/ngraph/core/src/op/squeeze.cpp
index 821a168e73f..7adfe93ce7a 100644
--- a/ngraph/core/src/op/squeeze.cpp
+++ b/ngraph/core/src/op/squeeze.cpp
@@ -19,6 +19,7 @@
 #include <set>
 
 #include "itt.hpp"
+#include "ngraph/builder/reshape.hpp"
 #include "ngraph/op/constant.hpp"
 #include "ngraph/op/reshape.hpp"
 #include "ngraph/op/squeeze.hpp"
@@ -122,10 +123,11 @@ OutputVector op::Squeeze::decompose_op() const
         (get_output_partial_shape(0).is_static()),
         "output shape was not calculated during pre_validate_and_infer_types. Can not decompose.");
     auto data = input_value(0);
-    auto data_shape = data.get_shape();
     auto output_data_shape = get_output_shape(0);
-    AxisVector input_order{get_default_order(data_shape.size())};
-    return {make_shared<op::Reshape>(data, input_order, output_data_shape)};
+    return {make_shared<op::v1::Reshape>(
+        data,
+        op::Constant::create(element::u64, {output_data_shape.size()}, output_data_shape),
+        false)};
 }
 
 shared_ptr<Node> op::Squeeze::clone_with_new_inputs(const OutputVector& new_args) const
@@ -241,4 +243,4 @@ bool op::v0::Squeeze::constant_fold(OutputVector& output_values, const OutputVec
         return true;
     }
     return false;
-}
\ No newline at end of file
+}
diff --git a/ngraph/core/src/op/unsqueeze.cpp b/ngraph/core/src/op/unsqueeze.cpp
index b033bb2c9c5..03a59630bd3 100644
--- a/ngraph/core/src/op/unsqueeze.cpp
+++ b/ngraph/core/src/op/unsqueeze.cpp
@@ -18,6 +18,7 @@
 #include <set>
 
 #include "itt.hpp"
+#include "ngraph/builder/reshape.hpp"
 #include "ngraph/op/constant.hpp"
 #include "ngraph/op/reshape.hpp"
 #include "ngraph/op/unsqueeze.hpp"
@@ -87,8 +88,7 @@ OutputVector op::Unsqueeze::decompose_op() const
     auto data = input_value(0);
     auto data_shape = data.get_shape();
     auto output_shape = get_output_shape(0);
-    AxisVector input_order{ngraph::get_default_order(data_shape.size())};
-    return {make_shared<ngraph::op::Reshape>(data, input_order, output_shape)};
+    return {builder::opset1::reshape(data, output_shape)};
 }
 
 bool ngraph::op::v0::Unsqueeze::visit_attributes(AttributeVisitor& visitor)
@@ -203,4 +203,4 @@ bool op::v0::Unsqueeze::constant_fold(OutputVector& output_values,
         return true;
     }
     return false;
-}
\ No newline at end of file
+}
diff --git a/ngraph/test/backend/dynamic.in.cpp b/ngraph/test/backend/dynamic.in.cpp
index 3fa206b6486..a7b21469063 100644
--- a/ngraph/test/backend/dynamic.in.cpp
+++ b/ngraph/test/backend/dynamic.in.cpp
@@ -184,7 +184,8 @@ static void to_vector_test(const PartialShape& input_pshape, const std::vector<S
     shared_ptr<Node> x_new_shape = make_shared<op::v0::ShapeOf>(x);
     auto axes = op::Constant::create(element::i64, {}, {0});
     x_new_shape = make_shared<op::v1::ReduceProd>(x_new_shape, axes);
-    x_new_shape = make_shared<op::Reshape>(x_new_shape, AxisVector{}, Shape{1});
+    x_new_shape = make_shared<op::v1::Reshape>(
+        x_new_shape, op::Constant::create(element::u64, {1}, Shape{1}), false);
 
     auto x_reshaped = make_shared<op::v1::Reshape>(x, x_new_shape, true);
 
@@ -298,3 +299,30 @@ NGRAPH_TEST(${BACKEND_NAME}, dynamic_reverse_shape)
                         Shape{8, 2, 8, 2},
                         Shape{2, 3, 4, 5, 2}});
 }
+
+NGRAPH_TEST(${BACKEND_NAME}, dynamic_transpose)
+{
+    auto arg = std::make_shared<op::Parameter>(element::i32, PartialShape::dynamic());
+    auto input_order = make_shared<op::Parameter>(element::i32, PartialShape::dynamic());
+    auto transpose = std::make_shared<op::v1::Transpose>(arg, input_order);
+
+    auto f = std::make_shared<Function>(NodeVector{transpose}, ParameterVector{arg, input_order});
+
+    auto backend = runtime::Backend::create("${BACKEND_NAME}", true);
+    auto ex = backend->compile(f);
+
+    auto arg_data = vector<int32_t>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+    auto input_order_data = vector<int32_t>{2, 0, 1};
+
+    auto arg_tensor = backend->create_tensor(element::i32, Shape{2, 2, 3});
+    auto input_order_tensor = backend->create_tensor(element::i32, Shape{input_order_data.size()});
+    copy_data(arg_tensor, arg_data);
+    copy_data(input_order_tensor, input_order_data);
+
+    auto output = backend->create_dynamic_tensor(element::i32, PartialShape::dynamic());
+    ex->call_with_validate({output}, {arg_tensor, input_order_tensor});
+
+    ASSERT_EQ(output->get_element_type(), element::i32);
+    EXPECT_EQ(read_vector<int32_t>(output),
+              vector<int32_t>({1, 4, 7, 10, 2, 5, 8, 11, 3, 6, 9, 12}));
+}
diff --git a/ngraph/test/backend/reshape.in.cpp b/ngraph/test/backend/reshape.in.cpp
index 3e703d2cdda..130629430b5 100644
--- a/ngraph/test/backend/reshape.in.cpp
+++ b/ngraph/test/backend/reshape.in.cpp
@@ -49,7 +49,8 @@ NGRAPH_TEST(${BACKEND_NAME}, reshape_t2v_012)
     Shape shape_a{2, 2, 3};
     auto A = make_shared<op::Parameter>(element::f32, shape_a);
     Shape shape_r{12};
-    auto r = make_shared<op::Reshape>(A, AxisVector{0, 1, 2}, shape_r);
+    auto r = make_shared<op::v1::Reshape>(
+        A, op::Constant::create(element::u64, {shape_r.size()}, shape_r), false);
     auto f = make_shared<Function>(r, ParameterVector{A});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
@@ -71,7 +72,8 @@ NGRAPH_TEST(${BACKEND_NAME}, reshape_t2s_012)
     Shape shape_a{1, 1, 1};
     auto A = make_shared<op::Parameter>(element::f32, shape_a);
     Shape shape_r{};
-    auto r = make_shared<op::Reshape>(A, AxisVector{0, 1, 2}, shape_r);
+    auto r = make_shared<op::v1::Reshape>(
+        A, op::Constant::create(element::u64, {shape_r.size()}, shape_r), false);
     auto f = make_shared<Function>(r, ParameterVector{A});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
@@ -92,7 +94,8 @@ NGRAPH_TEST(${BACKEND_NAME}, reshape_t2s_120)
     Shape shape_a{1, 1, 1};
     auto A = make_shared<op::Parameter>(element::f32, shape_a);
     Shape shape_r{};
-    auto r = make_shared<op::Reshape>(A, AxisVector{1, 2, 0}, shape_r);
+    auto r = make_shared<op::v1::Reshape>(
+        A, op::Constant::create(element::u64, {shape_r.size()}, shape_r), false);
     auto f = make_shared<Function>(r, ParameterVector{A});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
@@ -113,7 +116,8 @@ NGRAPH_TEST(${BACKEND_NAME}, reshape_s2t)
     Shape shape_a{};
     auto A = make_shared<op::Parameter>(element::f32, shape_a);
     Shape shape_r{1, 1, 1, 1, 1, 1};
-    auto r = make_shared<op::Reshape>(A, AxisVector{}, shape_r);
+    auto r = make_shared<op::v1::Reshape>(
+        A, op::Constant::create(element::u64, {shape_r.size()}, shape_r), false);
     auto f = make_shared<Function>(r, ParameterVector{A});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
@@ -134,7 +138,8 @@ NGRAPH_TEST(${BACKEND_NAME}, reshape_s2t1)
     Shape shape_a{};
     auto A = make_shared<op::Parameter>(element::boolean, shape_a);
     Shape shape_r{1};
-    auto r = make_shared<op::Reshape>(A, AxisVector{}, shape_r);
+    auto r = make_shared<op::v1::Reshape>(
+        A, op::Constant::create(element::u64, {shape_r.size()}, shape_r), false);
     auto f = make_shared<Function>(r, ParameterVector{A});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
@@ -154,7 +159,8 @@ NGRAPH_TEST(${BACKEND_NAME}, reshape_v2m_col)
     Shape shape_a{3};
     auto A = make_shared<op::Parameter>(element::f32, shape_a);
     Shape shape_r{3, 1};
-    auto r = make_shared<op::Reshape>(A, AxisVector{0}, shape_r);
+    auto r = make_shared<op::v1::Reshape>(
+        A, op::Constant::create(element::u64, {shape_r.size()}, shape_r), false);
     auto f = make_shared<Function>(r, ParameterVector{A});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
@@ -175,7 +181,8 @@ NGRAPH_TEST(${BACKEND_NAME}, reshape_v2m_row)
     Shape shape_a{3};
     auto A = make_shared<op::Parameter>(element::f32, shape_a);
     Shape shape_r{1, 3};
-    auto r = make_shared<op::Reshape>(A, AxisVector{0}, shape_r);
+    auto r = make_shared<op::v1::Reshape>(
+        A, op::Constant::create(element::u64, {shape_r.size()}, shape_r), false);
     auto f = make_shared<Function>(r, ParameterVector{A});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
@@ -196,7 +203,8 @@ NGRAPH_TEST(${BACKEND_NAME}, reshape_v2t_middle)
     Shape shape_a{3};
     auto A = make_shared<op::Parameter>(element::f32, shape_a);
     Shape shape_r{1, 3, 1};
-    auto r = make_shared<op::Reshape>(A, AxisVector{0}, shape_r);
+    auto r = make_shared<op::v1::Reshape>(
+        A, op::Constant::create(element::u64, {shape_r.size()}, shape_r), false);
     auto f = make_shared<Function>(r, ParameterVector{A});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
@@ -217,7 +225,8 @@ NGRAPH_TEST(${BACKEND_NAME}, reshape_m2m_same)
     Shape shape_a{3, 3};
     auto A = make_shared<op::Parameter>(element::f32, shape_a);
     Shape shape_r{3, 3};
-    auto r = make_shared<op::Reshape>(A, AxisVector{0, 1}, shape_r);
+    auto r = make_shared<op::v1::Reshape>(
+        A, op::Constant::create(element::u64, {shape_r.size()}, shape_r), false);
     auto f = make_shared<Function>(r, ParameterVector{A});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
@@ -234,217 +243,13 @@ NGRAPH_TEST(${BACKEND_NAME}, reshape_m2m_same)
                                   MIN_FLOAT_TOLERANCE_BITS));
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, reshape_m2m_transpose)
-{
-    Shape shape_a{3, 3};
-    auto A = make_shared<op::Parameter>(element::f32, shape_a);
-    Shape shape_r{3, 3};
-    auto r = make_shared<op::Reshape>(A, AxisVector{1, 0}, shape_r);
-    auto f = make_shared<Function>(r, ParameterVector{A});
-
-    auto backend = runtime::Backend::create("${BACKEND_NAME}");
-
-    // Create some tensors for input/output
-    auto a = backend->create_tensor(element::f32, shape_a);
-    copy_data(a, vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});
-    auto result = backend->create_tensor(element::f32, shape_r);
-
-    auto handle = backend->compile(f);
-    handle->call_with_validate({result}, {a});
-    EXPECT_TRUE(test::all_close_f((vector<float>{1, 4, 7, 2, 5, 8, 3, 6, 9}),
-                                  read_vector<float>(result),
-                                  MIN_FLOAT_TOLERANCE_BITS));
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, reshape_m2m_dim_change_transpose)
-{
-    Shape shape_a{3, 2};
-    auto A = make_shared<op::Parameter>(element::f32, shape_a);
-    Shape shape_r{2, 3};
-    auto r = make_shared<op::Reshape>(A, AxisVector{1, 0}, shape_r);
-    auto f = make_shared<Function>(r, ParameterVector{A});
-
-    auto backend = runtime::Backend::create("${BACKEND_NAME}");
-
-    // Create some tensors for input/output
-    auto a = backend->create_tensor(element::f32, shape_a);
-    copy_data(a, vector<float>{1, 2, 3, 4, 5, 6});
-    auto result = backend->create_tensor(element::f32, shape_r);
-
-    auto handle = backend->compile(f);
-    handle->call_with_validate({result}, {a});
-    EXPECT_TRUE(test::all_close_f(
-        (vector<float>{1, 3, 5, 2, 4, 6}), read_vector<float>(result), MIN_FLOAT_TOLERANCE_BITS));
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, reshape_3d_transpose_021)
-{
-    Shape shape_a{2, 3, 4};
-    Shape shape_r{2, 4, 3};
-    auto A = make_shared<op::Parameter>(element::f32, shape_a);
-    auto r = make_shared<op::Reshape>(A, AxisVector{0, 2, 1}, shape_r);
-    auto f = make_shared<Function>(r, ParameterVector{A});
-
-    vector<float> a_data(shape_size(shape_a));
-    iota(a_data.begin(), a_data.end(), 1.f);
-
-    auto backend = runtime::Backend::create("${BACKEND_NAME}");
-
-    // Create some tensors for input/output
-    auto a = backend->create_tensor(element::f32, shape_a);
-    copy_data(a, a_data);
-    auto result = backend->create_tensor(element::f32, shape_r);
-
-    auto handle = backend->compile(f);
-    handle->call_with_validate({result}, {a});
-    EXPECT_TRUE(test::all_close_f((vector<float>{1,  5,  9,  2,  6,  10, 3,  7,  11, 4,  8,  12,
-                                                 13, 17, 21, 14, 18, 22, 15, 19, 23, 16, 20, 24}),
-                                  read_vector<float>(result),
-                                  MIN_FLOAT_TOLERANCE_BITS));
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, reshape_3d_transpose_210)
-{
-    Shape shape_a{2, 3, 4};
-    Shape shape_r{4, 3, 2};
-    auto A = make_shared<op::Parameter>(element::f32, shape_a);
-    auto r = make_shared<op::Reshape>(A, AxisVector{2, 1, 0}, shape_r);
-    auto f = make_shared<Function>(r, ParameterVector{A});
-
-    vector<float> a_data(shape_size(shape_a));
-    iota(a_data.begin(), a_data.end(), 1.f);
-
-    auto backend = runtime::Backend::create("${BACKEND_NAME}");
-
-    // Create some tensors for input/output
-    auto a = backend->create_tensor(element::f32, shape_a);
-    copy_data(a, a_data);
-    auto result = backend->create_tensor(element::f32, shape_r);
-
-    auto handle = backend->compile(f);
-    handle->call_with_validate({result}, {a});
-    EXPECT_TRUE(test::all_close_f((vector<float>{1, 13, 5, 17, 9,  21, 2, 14, 6, 18, 10, 22,
-                                                 3, 15, 7, 19, 11, 23, 4, 16, 8, 20, 12, 24}),
-                                  read_vector<float>(result),
-                                  MIN_FLOAT_TOLERANCE_BITS));
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, reshape_3d_transpose_201)
-{
-    Shape shape_a{2, 3, 4};
-    Shape shape_r{4, 2, 3};
-    auto A = make_shared<op::Parameter>(element::f32, shape_a);
-    auto r = make_shared<op::Reshape>(A, AxisVector{2, 0, 1}, shape_r);
-    auto f = make_shared<Function>(r, ParameterVector{A});
-
-    vector<float> a_data(shape_size(shape_a));
-    iota(a_data.begin(), a_data.end(), 1.f);
-
-    auto backend = runtime::Backend::create("${BACKEND_NAME}");
-
-    // Create some tensors for input/output
-    auto a = backend->create_tensor(element::f32, shape_a);
-    copy_data(a, a_data);
-    auto result = backend->create_tensor(element::f32, shape_r);
-
-    auto handle = backend->compile(f);
-    handle->call_with_validate({result}, {a});
-    EXPECT_TRUE(test::all_close_f((vector<float>{1, 5, 9,  13, 17, 21, 2, 6, 10, 14, 18, 22,
-                                                 3, 7, 11, 15, 19, 23, 4, 8, 12, 16, 20, 24}),
-                                  read_vector<float>(result),
-                                  MIN_FLOAT_TOLERANCE_BITS));
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, reshape_3d_transpose_102)
-{
-    Shape shape_a{2, 3, 4};
-    Shape shape_r{3, 2, 4};
-    auto A = make_shared<op::Parameter>(element::f32, shape_a);
-    auto r = make_shared<op::Reshape>(A, AxisVector{1, 0, 2}, shape_r);
-    auto f = make_shared<Function>(r, ParameterVector{A});
-
-    vector<float> a_data(shape_size(shape_a));
-    iota(a_data.begin(), a_data.end(), 1.f);
-
-    auto backend = runtime::Backend::create("${BACKEND_NAME}");
-
-    // Create some tensors for input/output
-    auto a = backend->create_tensor(element::f32, shape_a);
-    copy_data(a, a_data);
-    auto result = backend->create_tensor(element::f32, shape_r);
-
-    auto handle = backend->compile(f);
-    handle->call_with_validate({result}, {a});
-    EXPECT_TRUE(test::all_close_f((vector<float>{1,  2,  3,  4,  13, 14, 15, 16, 5,  6,  7,  8,
-                                                 17, 18, 19, 20, 9,  10, 11, 12, 21, 22, 23, 24}),
-                                  read_vector<float>(result),
-                                  MIN_FLOAT_TOLERANCE_BITS));
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, reshape_3d_transpose_120)
-{
-    Shape shape_a{2, 3, 4};
-    Shape shape_r{3, 4, 2};
-    auto A = make_shared<op::Parameter>(element::f32, shape_a);
-    auto r = make_shared<op::Reshape>(A, AxisVector{1, 2, 0}, shape_r);
-    auto f = make_shared<Function>(r, ParameterVector{A});
-
-    vector<float> a_data(shape_size(shape_a));
-    iota(a_data.begin(), a_data.end(), 1.f);
-
-    auto backend = runtime::Backend::create("${BACKEND_NAME}");
-
-    // Create some tensors for input/output
-    auto a = backend->create_tensor(element::f32, shape_a);
-    copy_data(a, a_data);
-    auto result = backend->create_tensor(element::f32, shape_r);
-
-    auto handle = backend->compile(f);
-    handle->call_with_validate({result}, {a});
-    EXPECT_TRUE(test::all_close_f((vector<float>{1, 13, 2, 14, 3, 15, 4,  16, 5,  17, 6,  18,
-                                                 7, 19, 8, 20, 9, 21, 10, 22, 11, 23, 12, 24}),
-                                  read_vector<float>(result),
-                                  MIN_FLOAT_TOLERANCE_BITS));
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, reshape_4d_transpose)
+NGRAPH_TEST(${BACKEND_NAME}, reshape_special_zero)
 {
     Shape shape_a{2, 2, 5, 5};
     Shape shape_r{2, 5, 5, 2};
     auto A = make_shared<op::Parameter>(element::f32, shape_a);
-    auto r = make_shared<op::Reshape>(A, AxisVector{0, 2, 3, 1}, shape_r);
-    auto f = make_shared<Function>(r, ParameterVector{A});
-
-    vector<float> a_data(shape_size(shape_a));
-    iota(a_data.begin(), a_data.end(), 1.f);
-
-    auto backend = runtime::Backend::create("${BACKEND_NAME}");
-
-    // Create some tensors for input/output
-    auto a = backend->create_tensor(element::f32, shape_a);
-    copy_data(a, a_data);
-    auto result = backend->create_tensor(element::f32, shape_r);
-
-    auto handle = backend->compile(f);
-    handle->call_with_validate({result}, {a});
-    EXPECT_TRUE(test::all_close_f(
-        (vector<float>{1.,  26., 2.,  27., 3.,  28., 4.,  29., 5.,  30., 6.,  31., 7.,  32., 8.,
-                       33., 9.,  34., 10., 35., 11., 36., 12., 37., 13., 38., 14., 39., 15., 40.,
-                       16., 41., 17., 42., 18., 43., 19., 44., 20., 45., 21., 46., 22., 47., 23.,
-                       48., 24., 49., 25., 50., 51., 76., 52., 77., 53., 78., 54., 79., 55., 80.,
-                       56., 81., 57., 82., 58., 83., 59., 84., 60., 85., 61., 86., 62., 87., 63.,
-                       88., 64., 89., 65., 90., 66., 91., 67., 92., 68., 93., 69., 94., 70., 95.,
-                       71., 96., 72., 97., 73., 98., 74., 99., 75., 100.}),
-        read_vector<float>(result),
-        MIN_FLOAT_TOLERANCE_BITS));
-}
-
-NGRAPH_TEST(${BACKEND_NAME}, reshape_4d_no_transpose)
-{
-    Shape shape_a{2, 2, 5, 5};
-    Shape shape_r{2, 5, 5, 2};
-    auto A = make_shared<op::Parameter>(element::f32, shape_a);
-    auto r = make_shared<op::Reshape>(A, AxisVector{0, 1, 2, 3}, shape_r);
+    auto r = make_shared<op::v1::Reshape>(
+        A, op::Constant::create(element::u64, {4}, Shape{0, 5, 0, 2}), true);
     auto f = make_shared<Function>(r, ParameterVector{A});
 
     vector<float> a_data(shape_size(shape_a));
@@ -462,28 +267,6 @@ NGRAPH_TEST(${BACKEND_NAME}, reshape_4d_no_transpose)
     EXPECT_TRUE(test::all_close_f(a_data, read_vector<float>(result), MIN_FLOAT_TOLERANCE_BITS));
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, reshape_transposed_shape_change)
-{
-    Shape shape_a{2, 6};
-    auto A = make_shared<op::Parameter>(element::f32, shape_a);
-    Shape shape_r{12};
-    auto r = make_shared<op::Reshape>(A, AxisVector{1, 0}, shape_r);
-    auto f = make_shared<Function>(r, ParameterVector{A});
-
-    auto backend = runtime::Backend::create("${BACKEND_NAME}");
-
-    // Create some tensors for input/output
-    auto a = backend->create_tensor(element::f32, shape_a);
-    copy_data(a, vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12});
-    auto result = backend->create_tensor(element::f32, shape_r);
-
-    auto handle = backend->compile(f);
-    handle->call_with_validate({result}, {a});
-    EXPECT_TRUE(test::all_close_f((vector<float>{1, 7, 2, 8, 3, 9, 4, 10, 5, 11, 6, 12}),
-                                  read_vector<float>(result),
-                                  MIN_FLOAT_TOLERANCE_BITS));
-}
-
 //
 // Numpy:
 //
@@ -534,7 +317,8 @@ NGRAPH_TEST(${BACKEND_NAME}, reshape_6d)
     vector<float> a_data(shape_size(shape_a));
     iota(a_data.begin(), a_data.end(), 1.f);
 
-    auto r = make_shared<op::Reshape>(A, AxisVector{2, 4, 0, 5, 3, 1}, shape_r);
+    auto r = make_shared<op::v1::Reshape>(
+        A, op::Constant::create(element::u64, {shape_r.size()}, shape_r), false);
     auto f = make_shared<Function>(r, ParameterVector{A});
 
     auto backend = runtime::Backend::create("${BACKEND_NAME}");
@@ -547,31 +331,8 @@ NGRAPH_TEST(${BACKEND_NAME}, reshape_6d)
 
     auto handle = backend->compile(f);
     handle->call_with_validate({result}, {a});
-    EXPECT_TRUE(test::all_close_f(
-        (vector<float>{
-            1.,   73.,  9.,   81.,  17.,  89.,  2.,   74.,  10.,  82.,  18.,  90.,  3.,   75.,
-            11.,  83.,  19.,  91.,  4.,   76.,  12.,  84.,  20.,  92.,  145., 217., 153., 225.,
-            161., 233., 146., 218., 154., 226., 162., 234., 147., 219., 155., 227., 163., 235.,
-            148., 220., 156., 228., 164., 236., 5.,   77.,  13.,  85.,  21.,  93.,  6.,   78.,
-            14.,  86.,  22.,  94.,  7.,   79.,  15.,  87.,  23.,  95.,  8.,   80.,  16.,  88.,
-            24.,  96.,  149., 221., 157., 229., 165., 237., 150., 222., 158., 230., 166., 238.,
-            151., 223., 159., 231., 167., 239., 152., 224., 160., 232., 168., 240., 25.,  97.,
-            33.,  105., 41.,  113., 26.,  98.,  34.,  106., 42.,  114., 27.,  99.,  35.,  107.,
-            43.,  115., 28.,  100., 36.,  108., 44.,  116., 169., 241., 177., 249., 185., 257.,
-            170., 242., 178., 250., 186., 258., 171., 243., 179., 251., 187., 259., 172., 244.,
-            180., 252., 188., 260., 29.,  101., 37.,  109., 45.,  117., 30.,  102., 38.,  110.,
-            46.,  118., 31.,  103., 39.,  111., 47.,  119., 32.,  104., 40.,  112., 48.,  120.,
-            173., 245., 181., 253., 189., 261., 174., 246., 182., 254., 190., 262., 175., 247.,
-            183., 255., 191., 263., 176., 248., 184., 256., 192., 264., 49.,  121., 57.,  129.,
-            65.,  137., 50.,  122., 58.,  130., 66.,  138., 51.,  123., 59.,  131., 67.,  139.,
-            52.,  124., 60.,  132., 68.,  140., 193., 265., 201., 273., 209., 281., 194., 266.,
-            202., 274., 210., 282., 195., 267., 203., 275., 211., 283., 196., 268., 204., 276.,
-            212., 284., 53.,  125., 61.,  133., 69.,  141., 54.,  126., 62.,  134., 70.,  142.,
-            55.,  127., 63.,  135., 71.,  143., 56.,  128., 64.,  136., 72.,  144., 197., 269.,
-            205., 277., 213., 285., 198., 270., 206., 278., 214., 286., 199., 271., 207., 279.,
-            215., 287., 200., 272., 208., 280., 216., 288.}),
-        read_vector<float>(result),
-        MIN_FLOAT_TOLERANCE_BITS));
+    EXPECT_TRUE(test::all_close_f(a_data, read_vector<float>(result), MIN_FLOAT_TOLERANCE_BITS));
+    EXPECT_EQ(r->get_output_shape(0), shape_r);
 }
 
 NGRAPH_TEST(${BACKEND_NAME}, builder_reshape_1D_to_scalar)
@@ -619,9 +380,12 @@ NGRAPH_TEST(${BACKEND_NAME}, reshape_shufflenet_5d)
     vector<float> a_data(shape_size(shape_a));
     iota(a_data.begin(), a_data.end(), 1.f);
 
-    auto r0 = make_shared<op::Reshape>(A, AxisVector{0, 1, 2, 3}, shape_b);
-    auto r1 = make_shared<op::Reshape>(r0, AxisVector{0, 2, 1, 3, 4}, shape_c);
-    auto r2 = make_shared<op::Reshape>(r1, AxisVector{0, 1, 2, 3, 4}, shape_r);
+    auto r0 = make_shared<op::v1::Reshape>(
+        A, op::Constant::create(element::u64, {shape_b.size()}, shape_b), false);
+    auto r1 = make_shared<op::v1::Reshape>(
+        r0, op::Constant::create(element::u64, {shape_c.size()}, shape_c), false);
+    auto r2 = make_shared<op::v1::Reshape>(
+        r1, op::Constant::create(element::u64, {shape_r.size()}, shape_r), false);
     auto f = make_shared<Function>(r2, ParameterVector{A});
 
     auto ref_func = clone_function(*f);
diff --git a/ngraph/test/backend/slice.in.cpp b/ngraph/test/backend/slice.in.cpp
index cbbb4cb001b..dcdb3fb955c 100644
--- a/ngraph/test/backend/slice.in.cpp
+++ b/ngraph/test/backend/slice.in.cpp
@@ -15,6 +15,7 @@
 //*****************************************************************************
 
 #include "gtest/gtest.h"
+#include "ngraph/builder/reshape.hpp"
 #include "ngraph/ngraph.hpp"
 #include "ngraph/runtime/tensor.hpp"
 #include "runtime/backend.hpp"
@@ -197,15 +198,15 @@ NGRAPH_TEST(${BACKEND_NAME}, slice_matrix_axis_0_in_place_twice_overlap)
                                   MIN_FLOAT_TOLERANCE_BITS));
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, slice_matrix_axis_0_in_place_with_reshape)
+NGRAPH_TEST(${BACKEND_NAME}, slice_matrix_axis_0_in_place_with_transpose)
 {
     Shape shape_a{4, 5};
     auto A = make_shared<op::Parameter>(element::f32, shape_a);
     Shape shape_r{2, 4};
     auto B = make_shared<op::Slice>(A, Coordinate{1, 0}, Coordinate{4, 5});
-    auto C = make_shared<op::Reshape>(B, AxisVector{1, 0}, Shape{5, 3});
+    auto C = builder::opset1::transpose(B);
     auto D = make_shared<op::Slice>(C, Coordinate{1, 0}, Coordinate{5, 3});
-    auto E = make_shared<op::Reshape>(D, AxisVector{1, 0}, Shape{3, 4});
+    auto E = builder::opset1::transpose(D);
     auto r = make_shared<op::Slice>(E, Coordinate{1, 0}, Coordinate{3, 4});
     auto f = make_shared<Function>(r, ParameterVector{A});
 
diff --git a/ngraph/test/constant_folding.cpp b/ngraph/test/constant_folding.cpp
index 60915c057db..dfe150c5acd 100644
--- a/ngraph/test/constant_folding.cpp
+++ b/ngraph/test/constant_folding.cpp
@@ -210,61 +210,6 @@ TEST(constant_folding, constant_unsqueeze)
     ASSERT_TRUE(test::all_close_f(values_in, values_out, MIN_FLOAT_TOLERANCE_BITS));
 }
 
-TEST(constant_folding, constant_reshape)
-{
-    Shape shape_in{2, 4};
-    Shape shape_out{2, 4, 1};
-
-    vector<float> values_in{0, 1, 2, 3, 4, 5, 6, 7};
-    auto constant = make_shared<op::Constant>(element::f32, shape_in, values_in);
-    auto reshape = make_shared<op::Reshape>(constant, AxisVector{0, 1}, shape_out);
-    reshape->set_friendly_name("test");
-    auto f = make_shared<Function>(reshape, ParameterVector{});
-
-    pass::Manager pass_manager;
-    pass_manager.register_pass<pass::ConstantFolding>();
-    pass_manager.run_passes(f);
-
-    ASSERT_EQ(count_ops_of_type<op::Reshape>(f), 0);
-    ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
-
-    auto new_const =
-        as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
-    ASSERT_TRUE(new_const);
-    ASSERT_EQ(new_const->get_friendly_name(), "test");
-    auto values_out = new_const->get_vector<float>();
-
-    ASSERT_TRUE(test::all_close_f(values_in, values_out, MIN_FLOAT_TOLERANCE_BITS));
-}
-
-TEST(constant_folding, DISABLED_constant_reshape_permute)
-{
-    Shape shape_in{2, 4};
-    Shape shape_out{4, 2};
-
-    vector<double> values_in{0, 1, 2, 3, 4, 5, 6, 7};
-    auto constant = make_shared<op::Constant>(element::f64, shape_in, values_in);
-    auto reshape = make_shared<op::Reshape>(constant, AxisVector{1, 0}, shape_out);
-    reshape->set_friendly_name("test");
-    auto f = make_shared<Function>(reshape, ParameterVector{});
-
-    pass::Manager pass_manager;
-    pass_manager.register_pass<pass::ConstantFolding>();
-    pass_manager.run_passes(f);
-
-    ASSERT_EQ(count_ops_of_type<op::Reshape>(f), 0);
-    ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
-
-    auto new_const =
-        as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
-    ASSERT_TRUE(new_const);
-    ASSERT_EQ(new_const->get_friendly_name(), "test");
-    auto values_out = new_const->get_vector<double>();
-
-    vector<double> values_permute{0, 4, 1, 5, 2, 6, 3, 7};
-    ASSERT_TRUE(test::all_close_f(values_permute, values_out, MIN_FLOAT_TOLERANCE_BITS));
-}
-
 TEST(constant_folding, constant_broadcast_v1)
 {
     vector<int32_t> values_in{0, 1};
diff --git a/ngraph/test/copy.cpp b/ngraph/test/copy.cpp
index d7c51ab1a21..0c563c6d2e7 100644
--- a/ngraph/test/copy.cpp
+++ b/ngraph/test/copy.cpp
@@ -271,20 +271,20 @@ TEST(copy, power)
 TEST(copy, reshape)
 {
     Shape shape_in{2, 3, 4};
-    AxisVector axes{0, 1, 2};
     Shape shape_out{6, 4};
 
     auto arg0 = make_shared<op::Parameter>(element::f32, shape_in);
-    OutputVector new_args{make_shared<op::Parameter>(element::f32, shape_in)};
+    OutputVector new_args{make_shared<op::Parameter>(element::f32, shape_in),
+                          op::Constant::create(element::u64, {shape_out.size()}, shape_out)};
 
-    auto node = make_shared<op::Reshape>(arg0, axes, shape_out);
+    auto shape_pattern = op::Constant::create(element::u64, {shape_out.size()}, shape_out);
+    auto node = make_shared<op::v1::Reshape>(arg0, shape_pattern, false);
     auto new_node = node->clone_with_new_inputs(new_args);
-    auto node_cast = as_type_ptr<op::Reshape>(new_node);
+    auto node_cast = as_type_ptr<op::v1::Reshape>(new_node);
     ASSERT_NE(node_cast, nullptr);
 
     ASSERT_TRUE(nullptr != new_node);
     ASSERT_TRUE(new_args == new_node->input_values());
-    ASSERT_TRUE(axes == node_cast->get_input_order());
     ASSERT_TRUE(shape_out == node_cast->get_output_shape(0));
 }
 
diff --git a/ngraph/test/dyn_elimination.cpp b/ngraph/test/dyn_elimination.cpp
index f882564fc1f..a3474cabccb 100644
--- a/ngraph/test/dyn_elimination.cpp
+++ b/ngraph/test/dyn_elimination.cpp
@@ -44,10 +44,10 @@ TEST(dyn_elimination, transpose)
     pass_manager.run_passes(f);
 
     ASSERT_EQ(count_ops_of_type<op::Transpose>(f), 0);
-    ASSERT_EQ(count_ops_of_type<op::Reshape>(f), 1);
+    ASSERT_EQ(count_ops_of_type<op::v1::Reshape>(f), 1);
 
     auto new_reshape =
-        as_type_ptr<op::Reshape>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
+        as_type_ptr<op::v1::Reshape>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
     ASSERT_TRUE(new_reshape);
 
     ASSERT_EQ(new_reshape->get_input_order(), (AxisVector{2, 3, 1, 0}));
diff --git a/ngraph/test/op_is.cpp b/ngraph/test/op_is.cpp
index df2ce0f58a4..fe2f41c44c1 100644
--- a/ngraph/test/op_is.cpp
+++ b/ngraph/test/op_is.cpp
@@ -643,7 +643,7 @@ namespace
 
     void op_is_Reshape()
     {
-        op::Reshape node;
+        op::v1::Reshape node;
         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
diff --git a/ngraph/test/runtime/dynamic/dynamic_backend.cpp b/ngraph/test/runtime/dynamic/dynamic_backend.cpp
index fd60a7611fc..e7b6a48701e 100644
--- a/ngraph/test/runtime/dynamic/dynamic_backend.cpp
+++ b/ngraph/test/runtime/dynamic/dynamic_backend.cpp
@@ -89,8 +89,8 @@ runtime::dynamic::DynamicExecutable::DynamicExecutable(shared_ptr<Function> wrap
 // count_dyn_nodes.
 bool is_dynamic_op(const std::shared_ptr<Node>& op)
 {
-    return is_type<op::Transpose>(op) || is_type<op::v1::Reshape>(op) || is_type<op::Range>(op) ||
-           is_type<op::v1::ConvolutionBackpropData>(op) || is_type<op::v3::Broadcast>(op);
+    return is_type<op::Range>(op) || is_type<op::v1::ConvolutionBackpropData>(op) ||
+           is_type<op::v3::Broadcast>(op);
 }
 
 // Helper for a vile hack in DynamicExecutable::call. See body of that function for details.
diff --git a/ngraph/test/runtime/ie/unit_test.manifest b/ngraph/test/runtime/ie/unit_test.manifest
index 38911a86930..9f511562bb8 100644
--- a/ngraph/test/runtime/ie/unit_test.manifest
+++ b/ngraph/test/runtime/ie/unit_test.manifest
@@ -914,6 +914,9 @@ broadcast_algo_matrix_stride_1
 broadcast_algo_matrix_stride_2
 broadcast_algo_matrix_stride_3
 
+# Cannot find blob with name: Parameter_1
+dynamic_transpose
+
 # Failing from new reason after unblocking more Blob types
 gather_2d_negative_and_positive_indices_axis_0_2d_input
 gather_axis_0_int8
diff --git a/ngraph/test/runtime/interpreter/int_executable.hpp b/ngraph/test/runtime/interpreter/int_executable.hpp
index 6c27f436aec..b399f38deb3 100644
--- a/ngraph/test/runtime/interpreter/int_executable.hpp
+++ b/ngraph/test/runtime/interpreter/int_executable.hpp
@@ -1490,7 +1490,7 @@ protected:
         case OP_TYPEID::NotEqual:
         case OP_TYPEID::Power:
         case OP_TYPEID::Range:
-        case OP_TYPEID::Reshape:
+        case OP_TYPEID::Reshape_v1:
         case OP_TYPEID::Result:
         case OP_TYPEID::Reverse_v1:
         case OP_TYPEID::Round_v5:
diff --git a/ngraph/test/runtime/interpreter/opset_int_tbl.hpp b/ngraph/test/runtime/interpreter/opset_int_tbl.hpp
index 0c85a46b1c8..9c7711bbcf8 100644
--- a/ngraph/test/runtime/interpreter/opset_int_tbl.hpp
+++ b/ngraph/test/runtime/interpreter/opset_int_tbl.hpp
@@ -34,6 +34,7 @@ NGRAPH_OP(LogicalXor, op::v1)
 NGRAPH_OP(LogicalNot, op::v1)
 NGRAPH_OP(GatherTree, op::v1)
 NGRAPH_OP(OneHot, op::v1)
+NGRAPH_OP(Reshape, op::v1)
 NGRAPH_OP(Reverse, op::v1)
 #undef ID_SUFFIX
 
diff --git a/ngraph/test/runtime/op/group_conv.cpp b/ngraph/test/runtime/op/group_conv.cpp
index cd14a8c8470..587a0018641 100644
--- a/ngraph/test/runtime/op/group_conv.cpp
+++ b/ngraph/test/runtime/op/group_conv.cpp
@@ -23,7 +23,6 @@
 #include "ngraph/builder/split.hpp"
 #include "ngraph/op/concat.hpp"
 #include "ngraph/op/convolution.hpp"
-#include "ngraph/op/reshape.hpp"
 #include "ngraph/op/slice.hpp"
 #include "ngraph/validation_util.hpp"
 
@@ -203,16 +202,14 @@ OutputVector op::v0::GroupConvolution::decompose_op() const
     auto sliced_data = builder::split(data, get_groups(), 1);
     // slice filters
     auto sliced_filters = builder::split(filters, get_groups(), 0);
+    auto shape = Shape(std::next(std::begin(filters_shape), 1), std::end(filters_shape));
     for (std::size_t group{0}; group < get_groups(); ++group)
     {
         auto sliced_filter = sliced_filters[group];
         if (m_groups_in_filters)
         {
-            // Remove group dimmension after slicing
-            sliced_filter = make_shared<op::Reshape>(
-                sliced_filters[group],
-                get_default_order(sliced_filters[group].get_shape().size()),
-                Shape(std::next(std::begin(filters_shape), 1), std::end(filters_shape)));
+            // Remove group dimension after slicing
+            sliced_filter = builder::opset1::reshape(sliced_filters[group], shape);
         }
         convolution_nodes.push_back(
             std::make_shared<ngraph::op::v0::Convolution>(sliced_data[group],
diff --git a/ngraph/test/runtime/opset0_tbl.hpp b/ngraph/test/runtime/opset0_tbl.hpp
index c206bf083ab..344d9d43332 100644
--- a/ngraph/test/runtime/opset0_tbl.hpp
+++ b/ngraph/test/runtime/opset0_tbl.hpp
@@ -108,7 +108,6 @@ NGRAPH_OP(QuantizedConvolution, ngraph::op)
 NGRAPH_OP(QuantizedDot, ngraph::op)
 NGRAPH_OP(Range, ngraph::op)
 NGRAPH_OP(Relu, ngraph::op)
-NGRAPH_OP(Reshape, ngraph::op)
 NGRAPH_OP(Result, ngraph::op)
 NGRAPH_OP(ReverseSequence, ngraph::op)
 NGRAPH_OP(Select, ngraph::op)
diff --git a/ngraph/test/runtime/pass/dyn_elimination.cpp b/ngraph/test/runtime/pass/dyn_elimination.cpp
index dbdb7043b1a..ac0406d2340 100644
--- a/ngraph/test/runtime/pass/dyn_elimination.cpp
+++ b/ngraph/test/runtime/pass/dyn_elimination.cpp
@@ -17,9 +17,9 @@
 #include <numeric>
 
 #include "dyn_elimination.hpp"
+#include "ngraph/builder/reshape.hpp"
 #include "ngraph/op/broadcast.hpp"
 #include "ngraph/op/range.hpp"
-#include "ngraph/op/reshape.hpp"
 #include "ngraph/op/slice.hpp"
 #include "ngraph/op/transpose.hpp"
 #include "ngraph/pattern/matcher.hpp"
@@ -35,59 +35,9 @@ using namespace ngraph;
 pass::DynElimination::DynElimination()
     : GraphRewrite()
 {
-    construct_transpose();
     construct_range();
 }
 
-void pass::DynElimination::construct_transpose()
-{
-    auto data_arg_label = make_shared<pattern::op::Label>(element::f32, Shape{1, 2, 3});
-    auto perm_arg_label =
-        make_shared<pattern::op::Label>(element::i64, Shape{3}, pattern::has_class<op::Constant>());
-
-    auto transpose = make_shared<op::Transpose>(data_arg_label, perm_arg_label);
-
-    auto transpose_callback = [data_arg_label, perm_arg_label](pattern::Matcher& m) {
-        auto pattern_map = m.get_pattern_map();
-
-        auto data_arg = pattern_map[data_arg_label];
-        auto perm_arg = static_pointer_cast<op::Constant>(pattern_map[perm_arg_label]);
-
-        // TODO(amprocte): Can't handle the case where data shape is dynamic, because static
-        // Reshape requries the exact output shape to be declared. See if we can come up with a
-        // workaround.
-        if (data_arg->get_output_partial_shape(0).is_dynamic())
-        {
-            return false;
-        }
-
-        auto& data_shape = data_arg->get_output_shape(0);
-
-        NGRAPH_CHECK(perm_arg->get_output_partial_shape(0).rank().compatible(1));
-        NGRAPH_CHECK(perm_arg->get_output_element_type(0).compatible(element::i64));
-
-        if (perm_arg->get_output_element_type(0).is_dynamic() ||
-            perm_arg->get_output_partial_shape(0).is_dynamic())
-        {
-            return false;
-        }
-
-        auto perm = perm_arg->get_axis_vector_val();
-
-        auto output_shape = ngraph::apply_permutation(data_shape, perm);
-
-        auto replacement = std::make_shared<op::Reshape>(data_arg, perm, output_shape);
-
-        replace_node(m.get_match_root(), replacement);
-        return true;
-    };
-
-    auto transpose_matcher = make_shared<pattern::Matcher>(transpose, "DynElimination.Transpose");
-    NGRAPH_SUPPRESS_DEPRECATED_START
-    add_matcher(transpose_matcher, transpose_callback, all_pass_property_off);
-    NGRAPH_SUPPRESS_DEPRECATED_END
-}
-
 template <typename T>
 std::shared_ptr<op::Constant> make_range_replacement(const element::Type& et,
                                                      const Shape& shape,
diff --git a/ngraph/test/runtime/pass/dyn_elimination.hpp b/ngraph/test/runtime/pass/dyn_elimination.hpp
index 62aa0ac64ac..eed8fbd27d3 100644
--- a/ngraph/test/runtime/pass/dyn_elimination.hpp
+++ b/ngraph/test/runtime/pass/dyn_elimination.hpp
@@ -57,7 +57,6 @@ namespace ngraph
             DynElimination();
 
         private:
-            void construct_transpose();
             void construct_range();
         };
     }
diff --git a/ngraph/test/runtime/pass/opset0_downgrade.cpp b/ngraph/test/runtime/pass/opset0_downgrade.cpp
index ac41892e6f9..e450756d3a5 100644
--- a/ngraph/test/runtime/pass/opset0_downgrade.cpp
+++ b/ngraph/test/runtime/pass/opset0_downgrade.cpp
@@ -84,9 +84,10 @@ namespace opset0_downgrade
             {
                 reshaped_output_shape.insert(reshaped_output_shape.begin() + axis, 1);
             }
-            auto reshaped_product = make_shared<op::Reshape>(replacement_node->output(0),
-                                                             get_default_order(output_shape),
-                                                             reshaped_output_shape);
+            auto shape_pattern = op::Constant::create(
+                element::u64, {reshaped_output_shape.size()}, reshaped_output_shape);
+            auto reshaped_product =
+                make_shared<op::v1::Reshape>(replacement_node->output(0), shape_pattern, false);
             return reshaped_product;
         }
         else
@@ -190,28 +191,6 @@ namespace opset0_downgrade
         return replacement_node;
     }
 
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::Reshape> node)
-    {
-        shared_ptr<Node> replacement_node;
-
-        const auto target_shape_input = node->input_value(1).get_node_shared_ptr();
-        const auto input_rank = node->get_input_partial_shape(0).rank();
-        if (op::is_constant(target_shape_input) && node->get_output_partial_shape(0).is_static() &&
-            input_rank.is_static())
-        {
-            const auto output_shape = node->get_output_shape(0);
-            replacement_node = make_shared<op::Reshape>(
-                node->input_value(0), get_default_order(input_rank.get_length()), output_shape);
-        }
-        else
-        {
-            NGRAPH_CHECK(replacement_node, "Unable to convert Reshape:v1 with dynamic shape.");
-        }
-
-        replace_node(node, replacement_node);
-        return replacement_node;
-    }
-
     shared_ptr<Node> op_cast(shared_ptr<op::v1::Equal> node)
     {
         return op_cast_binary_elementwise_node<op::v0::Equal, op::v1::Equal>(node);
@@ -354,8 +333,9 @@ namespace opset0_downgrade
             {
                 reshaped_output_shape.insert(reshaped_output_shape.begin() + axis, 1);
             }
-            count_node = make_shared<op::Reshape>(
-                count_node->output(0), get_default_order(output_shape), reshaped_output_shape);
+            auto shape_pattern = op::Constant::create(
+                element::u64, {reshaped_output_shape.size()}, reshaped_output_shape);
+            count_node = make_shared<op::v1::Reshape>(count_node->output(0), shape_pattern, false);
         }
 
         const auto replacement_node =
@@ -431,10 +411,9 @@ namespace opset0_downgrade
 
         if (p.reshape_in_shape != p.reshape_out_shape)
         {
-            replacement_node =
-                make_shared<op::Reshape>(replacement_node,
-                                         ngraph::get_default_order(p.reshape_in_shape),
-                                         p.reshape_out_shape);
+            auto shape_pattern = op::Constant::create(
+                element::u64, {p.reshape_out_shape.size()}, p.reshape_out_shape);
+            replacement_node = make_shared<op::v1::Reshape>(replacement_node, shape_pattern, false);
         }
 
         if (!p.reverse_axes.empty())
@@ -492,44 +471,6 @@ namespace opset0_downgrade
         return replacement_node;
     }
 
-    shared_ptr<Node> op_cast(shared_ptr<op::v1::Transpose> node)
-    {
-        const auto data = node->input_value(0);
-
-        const auto data_pshape = data.get_partial_shape();
-        NGRAPH_CHECK(data_pshape.is_static(),
-                     "Unable to convert Transpose:v1 to Reshape:v0 "
-                     "if data shape is dynamic. Node: ",
-                     *node);
-        const auto data_shape = data_pshape.to_shape();
-
-        const auto order_node = node->input_value(1).get_node_shared_ptr();
-        NGRAPH_CHECK(op::is_constant(order_node),
-                     "Unable to convert Transpose:v1 to Reshape:v0 "
-                     "if order node is not constant. Node: ",
-                     *node);
-        const auto order_const = as_type_ptr<op::Constant>(order_node);
-
-        auto order = order_const->get_axis_vector_val();
-        Shape out_shape = data_shape;
-        if (order.empty())
-        {
-            order.resize(out_shape.size());
-            iota(begin(order), end(order), 0);
-        }
-        else
-        {
-            for (size_t i = 0; i < order.size(); ++i)
-            {
-                out_shape[i] = data_shape.at(order.at(i));
-            }
-        }
-
-        auto replacement_node = make_shared<op::v0::Reshape>(data, order, out_shape);
-        replace_node(node, replacement_node);
-        return replacement_node;
-    }
-
     shared_ptr<Node> op_cast(shared_ptr<op::v1::VariadicSplit> node)
     {
         const auto split_lengths = node->input_value(2).get_node_shared_ptr();
diff --git a/ngraph/test/runtime/pass/opset1_upgrade.cpp b/ngraph/test/runtime/pass/opset1_upgrade.cpp
index ed2a076fd97..32013c958db 100644
--- a/ngraph/test/runtime/pass/opset1_upgrade.cpp
+++ b/ngraph/test/runtime/pass/opset1_upgrade.cpp
@@ -127,14 +127,6 @@ namespace opset1_upgrade
         return replacement_node;
     }
 
-    shared_ptr<Node> op_cast(shared_ptr<op::Reshape> node)
-    {
-        shared_ptr<Node> replacement_node =
-            builder::opset1::reshape(node->input_value(0), node->get_reshape_output_shape());
-        replace_node(node, replacement_node);
-        return replacement_node;
-    }
-
     shared_ptr<Node> op_cast(shared_ptr<op::Equal> node)
     {
         return op_cast_binary_elementwise_node<op::v0::Equal, op::v1::Equal>(node);
diff --git a/ngraph/test/type_prop/reshape.cpp b/ngraph/test/type_prop/reshape.cpp
index a689ac4cb5a..0d2f73b60bf 100644
--- a/ngraph/test/type_prop/reshape.cpp
+++ b/ngraph/test/type_prop/reshape.cpp
@@ -18,15 +18,14 @@
 #include "ngraph/ngraph.hpp"
 #include "util/type_prop.hpp"
 
-NGRAPH_SUPPRESS_DEPRECATED_START
-
 using namespace std;
 using namespace ngraph;
 
 TEST(type_prop, reshape_deduce_s2v)
 {
     auto param = make_shared<op::Parameter>(element::f32, Shape{});
-    auto r = make_shared<op::Reshape>(param, AxisVector{}, Shape{1});
+    auto r = make_shared<op::v1::Reshape>(
+        param, op::Constant::create(element::u64, {1}, Shape{1}), false);
     ASSERT_EQ(r->get_element_type(), element::f32);
     ASSERT_EQ(r->get_shape(), (Shape{1}));
 }
@@ -34,7 +33,8 @@ TEST(type_prop, reshape_deduce_s2v)
 TEST(type_prop, reshape_deduce_s2m)
 {
     auto param = make_shared<op::Parameter>(element::f32, Shape{});
-    auto r = make_shared<op::Reshape>(param, AxisVector{}, Shape{1, 1});
+    auto r = make_shared<op::v1::Reshape>(
+        param, op::Constant::create(element::u64, {2}, Shape{1, 1}), false);
     ASSERT_EQ(r->get_element_type(), element::f32);
     ASSERT_EQ(r->get_shape(), (Shape{1, 1}));
 }
@@ -42,39 +42,17 @@ TEST(type_prop, reshape_deduce_s2m)
 TEST(type_prop, reshape_deduce_s2t)
 {
     auto param = make_shared<op::Parameter>(element::f32, Shape{});
-    auto r = make_shared<op::Reshape>(param, AxisVector{}, Shape{1, 1, 1});
+    auto r = make_shared<op::v1::Reshape>(
+        param, op::Constant::create(element::u64, {3}, Shape{1, 1, 1}), false);
     ASSERT_EQ(r->get_element_type(), element::f32);
     ASSERT_EQ(r->get_shape(), (Shape{1, 1, 1}));
 }
 
-TEST(type_prop, reshape_deduce_v2s)
-{
-    auto param = make_shared<op::Parameter>(element::f32, Shape{1});
-    auto r = make_shared<op::Reshape>(param, AxisVector{0}, Shape{});
-    ASSERT_EQ(r->get_element_type(), element::f32);
-    ASSERT_EQ(r->get_shape(), (Shape{}));
-}
-
-TEST(type_prop, reshape_deduce_m2s)
-{
-    auto param = make_shared<op::Parameter>(element::f32, Shape{1, 1});
-    auto r = make_shared<op::Reshape>(param, AxisVector{0, 1}, Shape{});
-    ASSERT_EQ(r->get_element_type(), element::f32);
-    ASSERT_EQ(r->get_shape(), (Shape{}));
-}
-
-TEST(type_prop, reshape_deduce_t2s)
-{
-    auto param = make_shared<op::Parameter>(element::f32, Shape{1, 1, 1});
-    auto r = make_shared<op::Reshape>(param, AxisVector{0, 1, 2}, Shape{});
-    ASSERT_EQ(r->get_element_type(), element::f32);
-    ASSERT_EQ(r->get_shape(), (Shape{}));
-}
-
 TEST(type_prop, reshape_deduce_m2v_01)
 {
     auto param = make_shared<op::Parameter>(element::f32, Shape{3, 4});
-    auto r = make_shared<op::Reshape>(param, AxisVector{0, 1}, Shape{12});
+    auto r = make_shared<op::v1::Reshape>(
+        param, op::Constant::create(element::u64, {1}, Shape{12}), false);
     ASSERT_EQ(r->get_element_type(), element::f32);
     ASSERT_EQ(r->get_shape(), (Shape{12}));
 }
@@ -82,7 +60,8 @@ TEST(type_prop, reshape_deduce_m2v_01)
 TEST(type_prop, reshape_deduce_m2v_10)
 {
     auto param = make_shared<op::Parameter>(element::f32, Shape{3, 4});
-    auto r = make_shared<op::Reshape>(param, AxisVector{1, 0}, Shape{12});
+    auto r = make_shared<op::v1::Reshape>(
+        param, op::Constant::create(element::u64, {1}, Shape{12}), false);
     ASSERT_EQ(r->get_element_type(), element::f32);
     ASSERT_EQ(r->get_shape(), (Shape{12}));
 }
@@ -90,7 +69,8 @@ TEST(type_prop, reshape_deduce_m2v_10)
 TEST(type_prop, reshape_deduce_t2v_012)
 {
     auto param = make_shared<op::Parameter>(element::f32, Shape{3, 4, 5});
-    auto r = make_shared<op::Reshape>(param, AxisVector{0, 1, 2}, Shape{60});
+    auto r = make_shared<op::v1::Reshape>(
+        param, op::Constant::create(element::u64, {1}, Shape{60}), false);
     ASSERT_EQ(r->get_element_type(), element::f32);
     ASSERT_EQ(r->get_shape(), (Shape{60}));
 }
@@ -98,72 +78,19 @@ TEST(type_prop, reshape_deduce_t2v_012)
 TEST(type_prop, reshape_deduce_t2v_120)
 {
     auto param = make_shared<op::Parameter>(element::f32, Shape{3, 4, 5});
-    auto r = make_shared<op::Reshape>(param, AxisVector{1, 2, 0}, Shape{60});
+    auto r = make_shared<op::v1::Reshape>(
+        param, op::Constant::create(element::u64, {1}, Shape{60}), false);
     ASSERT_EQ(r->get_element_type(), element::f32);
     ASSERT_EQ(r->get_shape(), (Shape{60}));
 }
 
-TEST(type_prop, reshape_deduce_not_enough_axes)
+TEST(type_prop, reshape_deduce_zero_special)
 {
     auto param = make_shared<op::Parameter>(element::f32, Shape{3, 4, 5});
-    try
-    {
-        auto r = make_shared<op::Reshape>(param, AxisVector{1, 0}, Shape{60});
-        // Should have thrown, so fail if it didn't
-        FAIL() << "Not enough axes not detected";
-    }
-    catch (const NodeValidationFailure& error)
-    {
-        EXPECT_HAS_SUBSTRING(
-            error.what(),
-            std::string("Input axis order is not a permutation of argument's axis indices"));
-    }
-    catch (...)
-    {
-        FAIL() << "Deduced type check failed for unexpected reason";
-    }
-}
-
-TEST(type_prop, reshape_deduce_too_many_axes)
-{
-    auto param = make_shared<op::Parameter>(element::f32, Shape{3, 4, 5});
-    try
-    {
-        auto r = make_shared<op::Reshape>(param, AxisVector{1, 2, 0, 3}, Shape{60});
-        // Should have thrown, so fail if it didn't
-        FAIL() << "Too many axes not detected";
-    }
-    catch (const NodeValidationFailure& error)
-    {
-        EXPECT_HAS_SUBSTRING(
-            error.what(),
-            std::string("Input axis order is not a permutation of argument's axis indices"));
-    }
-    catch (...)
-    {
-        FAIL() << "Deduced type check failed for unexpected reason";
-    }
-}
-
-TEST(type_prop, reshape_deduce_duplicate_axes)
-{
-    auto param = make_shared<op::Parameter>(element::f32, Shape{3, 4, 5});
-    try
-    {
-        auto r = make_shared<op::Reshape>(param, AxisVector{1, 1, 0}, Shape{60});
-        // Should have thrown, so fail if it didn't
-        FAIL() << "Too many axes not detected";
-    }
-    catch (const NodeValidationFailure& error)
-    {
-        EXPECT_HAS_SUBSTRING(
-            error.what(),
-            std::string("Input axis order is not a permutation of argument's axis indices"));
-    }
-    catch (...)
-    {
-        FAIL() << "Deduced type check failed for unexpected reason";
-    }
+    auto r = make_shared<op::v1::Reshape>(
+        param, op::Constant::create(element::u64, {3}, Shape{6, 2, 0}), true);
+    ASSERT_EQ(r->get_element_type(), element::f32);
+    ASSERT_EQ(r->get_shape(), (Shape{6, 2, 5}));
 }
 
 TEST(type_prop, reshape_deduce_wrong_output_shape)
@@ -171,49 +98,16 @@ TEST(type_prop, reshape_deduce_wrong_output_shape)
     auto param = make_shared<op::Parameter>(element::f32, Shape{3, 4, 5});
     try
     {
-        auto r = make_shared<op::Reshape>(param, AxisVector{1, 2, 0}, Shape{3, 3, 3});
+        auto r = make_shared<op::v1::Reshape>(
+            param, op::Constant::create(element::u64, {3}, Shape{3, 3, 3}), false);
         // Should have thrown, so fail if it didn't
-        FAIL() << "Too many axes not detected";
-    }
-    catch (const NodeValidationFailure& error)
-    {
-        EXPECT_HAS_SUBSTRING(error.what(),
-                             std::string("Product of output shape dimensions does not match "
-                                         "product of argument shape dimensions"));
-    }
-    catch (...)
-    {
-        FAIL() << "Deduced type check failed for unexpected reason";
-    }
-}
-
-//
-// Input shape rank dynamic, so we should set the desired output shape if the axis vector is not
-// known invalid (invalid means it's not a permutation of {0,...,n-1} for any n).
-//
-TEST(type_prop, reshape_partial_rank_dynamic_axisvector_ok)
-{
-    auto param = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
-    auto r = make_shared<op::Reshape>(param, AxisVector{2, 1, 0, 3}, Shape{3, 1, 8, 2});
-    ASSERT_EQ(r->get_element_type(), element::f32);
-    ASSERT_TRUE(r->get_output_partial_shape(0).is_static());
-    ASSERT_EQ(r->get_shape(), (Shape{3, 1, 8, 2}));
-}
-
-TEST(type_prop, reshape_partial_rank_dynamic_axisvector_not_ok)
-{
-    auto param = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
-    try
-    {
-        auto r = make_shared<op::Reshape>(param, AxisVector{2, 1, 0, 4}, Shape{3, 1, 8, 2});
-        // Should have thrown, so fail if it didn't
-        FAIL() << "Did not detect malformed AxisVector (input shape rank dynamic)";
+        FAIL() << "No exception was thrown";
     }
     catch (const NodeValidationFailure& error)
     {
         EXPECT_HAS_SUBSTRING(
             error.what(),
-            std::string("Input axis order is not a permutation of argument's axis indices"));
+            std::string("Check 'shape_size(get_input_shape(0)) == shape_size(output_shape)'"));
     }
     catch (...)
     {
@@ -222,41 +116,31 @@ TEST(type_prop, reshape_partial_rank_dynamic_axisvector_not_ok)
 }
 
 //
-// Input shape rank static but input shape is dynamic, so should set desired output shape if the
-// axis vector is consistent with the static rank.
+// Input shape rank dynamic, so we should set the desired output shape
 //
-TEST(type_prop, reshape_partial_rank_static_dynamic_axisvector_ok)
+TEST(type_prop, reshape_partial_rank_dynamic)
 {
-    auto param_shape =
-        PartialShape{Dimension::dynamic(), 6, Dimension::dynamic(), Dimension::dynamic()};
-    auto param = make_shared<op::Parameter>(element::f32, param_shape);
-    auto r = make_shared<op::Reshape>(param, AxisVector{2, 1, 0, 3}, Shape{3, 1, 8, 2});
+    auto param = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
+    auto r = make_shared<op::v1::Reshape>(
+        param, op::Constant::create(element::u64, {4}, Shape{3, 1, 8, 2}), false);
     ASSERT_EQ(r->get_element_type(), element::f32);
     ASSERT_TRUE(r->get_output_partial_shape(0).is_static());
     ASSERT_EQ(r->get_shape(), (Shape{3, 1, 8, 2}));
 }
 
-TEST(type_prop, reshape_partial_rank_static_dynamic_axisvector_not_ok)
+//
+// Input shape rank static but input shape is dynamic, so should set desired output shape
+//
+TEST(type_prop, reshape_partial_rank_static)
 {
     auto param_shape =
         PartialShape{Dimension::dynamic(), 6, Dimension::dynamic(), Dimension::dynamic()};
     auto param = make_shared<op::Parameter>(element::f32, param_shape);
-    try
-    {
-        auto r = make_shared<op::Reshape>(param, AxisVector{2, 1, 0}, Shape{3, 1, 8, 2});
-        // Should have thrown, so fail if it didn't
-        FAIL() << "Did not detect AxisVector inconsistent with rank (rank-static dynamic shape)";
-    }
-    catch (const NodeValidationFailure& error)
-    {
-        EXPECT_HAS_SUBSTRING(
-            error.what(),
-            std::string("Input axis order is not a permutation of argument's axis indices"));
-    }
-    catch (...)
-    {
-        FAIL() << "Deduced type check failed for unexpected reason";
-    }
+    auto r = make_shared<op::v1::Reshape>(
+        param, op::Constant::create(element::u64, {4}, Shape{3, 1, 8, 2}), false);
+    ASSERT_EQ(r->get_element_type(), element::f32);
+    ASSERT_TRUE(r->get_output_partial_shape(0).is_static());
+    ASSERT_EQ(r->get_shape(), (Shape{3, 1, 8, 2}));
 }
 
 //
@@ -268,32 +152,9 @@ TEST(type_prop, reshape_partial_rank_static_dynamic_but_zero_ok)
     auto param_shape =
         PartialShape{Dimension::dynamic(), 0, Dimension::dynamic(), Dimension::dynamic()};
     auto param = make_shared<op::Parameter>(element::f32, PartialShape::dynamic());
-    auto r = make_shared<op::Reshape>(param, AxisVector{2, 1, 0, 3}, Shape{3, 1, 0, 2});
+    auto r = make_shared<op::v1::Reshape>(
+        param, op::Constant::create(element::u64, {4}, Shape{3, 1, 0, 2}), false);
     ASSERT_EQ(r->get_element_type(), element::f32);
     ASSERT_TRUE(r->get_output_partial_shape(0).is_static());
     ASSERT_EQ(r->get_shape(), (Shape{3, 1, 0, 2}));
 }
-
-TEST(type_prop, reshape_partial_rank_static_dynamic_but_zero_not_ok)
-{
-    auto param_shape =
-        PartialShape{Dimension::dynamic(), 0, Dimension::dynamic(), Dimension::dynamic()};
-    auto param = make_shared<op::Parameter>(element::f32, param_shape);
-    try
-    {
-        auto r = make_shared<op::Reshape>(param, AxisVector{2, 1, 0}, Shape{3, 1, 8, 2});
-        // Should have thrown, so fail if it didn't
-        FAIL() << "Did not detect inconsistent output shape with static-zero-element rank-dynamic"
-                  " static input shape";
-    }
-    catch (const NodeValidationFailure& error)
-    {
-        EXPECT_HAS_SUBSTRING(
-            error.what(),
-            std::string("Input axis order is not a permutation of argument's axis indices"));
-    }
-    catch (...)
-    {
-        FAIL() << "Deduced type check failed for unexpected reason";
-    }
-}
diff --git a/ngraph/test/type_prop/ti.cpp b/ngraph/test/type_prop/ti.cpp
index a7d6938b95f..6fdc2241c00 100644
--- a/ngraph/test/type_prop/ti.cpp
+++ b/ngraph/test/type_prop/ti.cpp
@@ -15,6 +15,7 @@
 //*****************************************************************************
 
 #include "gtest/gtest.h"
+#include "ngraph/builder/reshape.hpp"
 #include "ngraph/ngraph.hpp"
 #include "ngraph/opsets/opset5.hpp"
 #include "util/type_prop.hpp"
@@ -43,15 +44,14 @@ TEST(type_prop, tensor_iterator_lstm)
     auto X = make_shared<op::Parameter>(element::f32, Shape{N, 1, I});
     auto W_body = make_shared<op::Parameter>(element::f32, Shape{4 * H, I});
     auto R_body = make_shared<op::Parameter>(element::f32, Shape{4 * H, H});
-    auto LSTM_cell = make_shared<opset5::LSTMCell>(
-        make_shared<op::Reshape>(X, AxisVector{0, 1, 2}, Shape{N, I}),
-        make_shared<op::Reshape>(H_t, AxisVector{0, 1, 2}, Shape{N, H}),
-        make_shared<op::Reshape>(C_t, AxisVector{0, 1, 2}, Shape{N, H}),
-        W_body,
-        R_body,
-        H);
-    auto H_o = make_shared<op::Reshape>(LSTM_cell->output(0), AxisVector{0, 1}, Shape{N, 1, H});
-    auto C_o = make_shared<op::Reshape>(LSTM_cell->output(1), AxisVector{0, 1}, Shape{N, 1, H});
+    auto LSTM_cell = make_shared<opset5::LSTMCell>(builder::opset1::reshape(X, Shape{N, I}),
+                                                   builder::opset1::reshape(H_t, Shape{N, H}),
+                                                   builder::opset1::reshape(C_t, Shape{N, H}),
+                                                   W_body,
+                                                   R_body,
+                                                   H);
+    auto H_o = builder::opset1::reshape(LSTM_cell->output(0), Shape{N, 1, H});
+    auto C_o = builder::opset1::reshape(LSTM_cell->output(1), Shape{N, 1, H});
     auto body = make_shared<ngraph::Function>(OutputVector{H_o, C_o},
                                               ParameterVector{X, H_t, C_t, W_body, R_body});