Added groups for core headers (#11068)

src/core/include/openvino/core/dimension.hpp

@@ -20,6 +20,7 @@ class TableOfEquivalence;
 ///
 /// Static dimensions may be implicitly converted from value_type. A dynamic dimension is
 /// constructed with Dimension() or Dimension::dynamic().
+/// \ingroup ov_model_cpp_api
 class OPENVINO_API Dimension {
 public:
     using value_type = int64_t;

src/core/include/openvino/core/extension.hpp

@@ -26,6 +26,7 @@ class Extension;
 
 /**
  * @brief The class provides the base interface for OpenVINO extensions
+ * @ingroup ov_model_cpp_api
  */
 class OPENVINO_API Extension {
 public:

src/core/include/openvino/core/graph_util.hpp

@@ -263,12 +263,13 @@ std::vector<std::shared_ptr<Node>> topological_sort(T root_nodes) {
 // NodeMap input may contain default node mapping i.e. pre-cloned nodes
 // NodeMap output (by reference) fully maps input and cloned Model ops
 OPENVINO_API
-std::shared_ptr<ov::Model> clone_model(const ov::Model& func,
+std::shared_ptr<ov::Model> clone_model(const ov::Model& model,
                                        std::unordered_map<Node*, std::shared_ptr<Node>>& node_map);
 
-// input model is cloned and returned
+/// \brief input model is cloned and returned
+/// \ingroup ov_model_cpp_api
 OPENVINO_API
-std::shared_ptr<ov::Model> clone_model(const ov::Model& func);
+std::shared_ptr<ov::Model> clone_model(const ov::Model& model);
 
 OPENVINO_API
 bool compare_constants(const std::shared_ptr<Node>& n1, const std::shared_ptr<Node>& n2);

src/core/include/openvino/core/layout.hpp

@@ -16,6 +16,13 @@
 
 namespace ov {
 
+/**
+ * @defgroup ov_layout_cpp_api Layout
+ * @ingroup ov_model_cpp_api
+ * OpenVINO Layout API to work and configure layouts for ov::Model inputs or outputs
+ *
+ */
+
 /// \brief ov::Layout represents the text information of tensor's dimensions/axes. E.g. layout `NCHW` means that 4D
 /// tensor `{-1, 3, 480, 640}` will have:
 /// - 0: `N = -1`: batch dimension is dynamic
@@ -33,6 +40,7 @@ namespace ov {
 /// in layout for appropriate inputs
 ///
 /// Refer also to `ov::layout` namespace for various additional helper functions of `ov::Layout`
+/// \ingroup ov_layout_cpp_api
 class OPENVINO_API Layout {
 public:
     /// \brief Constructs a dynamic Layout with no layout information.
@@ -101,66 +109,79 @@ private:
 namespace layout {
 
 /// \brief Checks if layout has 'batch' dimension
+/// \ingroup ov_layout_cpp_api
 OPENVINO_API bool has_batch(const Layout& layout);
 
 /// \brief Returns 'batch' dimension index.
 ///
 /// \throws ov::AssertFailure if dimension doesn't exist.
 ///
+/// \ingroup ov_layout_cpp_api
 OPENVINO_API std::int64_t batch_idx(const Layout& layout);
 
 /// \brief Checks if layout has 'channels' dimension
 ///
 /// \throws ov::AssertFailure if dimension doesn't exist.
 ///
+/// \ingroup ov_layout_cpp_api
 OPENVINO_API bool has_channels(const Layout& layout);
 
 /// \brief Returns 'channels' dimension index.
 ///
 /// \throws ov::AssertFailure if dimension doesn't exist.
 ///
+/// \ingroup ov_layout_cpp_api
 OPENVINO_API std::int64_t channels_idx(const Layout& layout);
 
 /// \brief Checks if layout has 'depth' dimension
+/// \ingroup ov_layout_cpp_api
 OPENVINO_API bool has_depth(const Layout& layout);
 
 /// \brief Returns 'depth' dimension index.
 ///
 /// \throws ov::AssertFailure if dimension doesn't exist.
 ///
+/// \ingroup ov_layout_cpp_api
 OPENVINO_API std::int64_t depth_idx(const Layout& layout);
 
 /// \brief Checks if layout has 'height' dimension
+/// \ingroup ov_layout_cpp_api
 OPENVINO_API bool has_height(const Layout& layout);
 
 /// \brief Returns 'height' dimension index.
 ///
 /// \throws ov::AssertFailure if dimension doesn't exist.
 ///
+/// \ingroup ov_layout_cpp_api
 OPENVINO_API std::int64_t height_idx(const Layout& layout);
 
 /// \brief Checks if layout has 'width' dimension
+/// \ingroup ov_layout_cpp_api
 OPENVINO_API bool has_width(const Layout& layout);
 
 /// \brief Returns 'width' dimension index.
 ///
 /// \throws ov::AssertFailure if dimension doesn't exist.
 ///
+/// \ingroup ov_layout_cpp_api
 OPENVINO_API std::int64_t width_idx(const Layout& layout);
 
 /// \brief Sets Layout of port
 ///
 /// \throws ov::Exception if port is not connected with Result or Parameter
+/// \ingroup ov_layout_cpp_api
 OPENVINO_API void set_layout(ov::Output<ov::Node> output, const ov::Layout& layout);
 
 /// \brief Gets Layout of port
 ///
 /// \return layout from port and empty layout in other case
+/// \ingroup ov_layout_cpp_api
 OPENVINO_API ov::Layout get_layout(const ov::Output<ov::Node>& output);
 
 /// \brief Gets Layout of port
 ///
 /// \return layout from port and empty layout in other case
+/// \ingroup ov_layout_cpp_api
 OPENVINO_API ov::Layout get_layout(const ov::Output<const ov::Node>& output);
 
 }  // namespace layout

src/core/include/openvino/core/node.hpp

@@ -110,9 +110,12 @@ std::string node_validation_failure_loc_string(const Node* node);
 
 class NodeAccessor;
 
-/// Nodes are the backbone of the graph of Value dataflow. Every node has
-/// zero or more nodes as arguments and one value, which is either a tensor
-/// or a (possibly empty) tuple of values.
+/**
+ * @brief Nodes are the backbone of the graph of Value dataflow. Every node has
+ * zero or more nodes as arguments and one value, which is either a tensor
+ * or a (possibly empty) tuple of values.
+ * @ingroup ov_model_cpp_api
+ */
 class OPENVINO_API Node : public std::enable_shared_from_this<Node> {
     // For access to m_outputs.
     friend class descriptor::Input;

src/core/include/openvino/core/node_input.hpp

@@ -24,6 +24,7 @@ template <typename NodeType>
 class Input {};
 
 /// \brief A handle for one of a node's inputs.
+/// \ingroup ov_model_cpp_api
 template <>
 class OPENVINO_API Input<Node> {
 public:
@@ -75,6 +76,7 @@ private:
 };
 
 /// \brief A handle for one of a node's inputs.
+/// \ingroup ov_model_cpp_api
 template <>
 class OPENVINO_API Input<const Node> {
 public:

src/core/include/openvino/core/node_output.hpp

@@ -25,6 +25,7 @@ template <typename NodeType>
 class Output {};
 
 /// \brief A handle for one of a node's outputs.
+/// \ingroup ov_model_cpp_api
 template <>
 class OPENVINO_API Output<Node> {
 public:
@@ -108,6 +109,8 @@ private:
     size_t m_index{0};
 };
 
+/// \brief A handle for one of a node's outputs.
+/// \ingroup ov_model_cpp_api
 template <>
 class OPENVINO_API Output<const Node> {
 public:

src/core/include/openvino/core/partial_shape.hpp

@@ -27,6 +27,7 @@ struct AutoBroadcastSpec;
 ///     (Informal notation examples: `{1,2,?,4}`, `{?,?,?}`)
 /// \li Static rank, and static dimensions on all axes.
 ///     (Informal notation examples: `{1,2,3,4}`, `{6}`, `{}`)
+/// \ingroup ov_model_cpp_api
 class OPENVINO_API PartialShape {
     using Dimensions = std::vector<Dimension>;
 

src/core/include/openvino/core/preprocess/pre_post_process.hpp

@@ -22,6 +22,7 @@ namespace preprocess {
 /// For advanced preprocessing scenarios, like combining several functions with multiple inputs/outputs into one,
 /// client's code can use transformation passes over ov::Model
 ///
+/// \ingroup ov_model_cpp_api
 class OPENVINO_API PrePostProcessor final {
     class PrePostProcessorImpl;
     std::unique_ptr<PrePostProcessorImpl> m_impl;

src/core/include/openvino/core/shape.hpp

@@ -14,7 +14,10 @@
 #include "openvino/core/strides.hpp"
 
 namespace ov {
-/// \brief Shape for a tensor.
+/**
+ * @brief Shape for a tensor.
+ * @ingroup ov_model_cpp_api
+ */
 class Shape : public std::vector<size_t> {
 public:
     OPENVINO_API Shape();
@@ -36,7 +39,10 @@ public:
     OPENVINO_API Shape& operator=(Shape&& v) noexcept;
 };
 
-/// Number of elements in spanned by a shape
+/**
+ * @brief Number of elements in spanned by a shape
+ * @ingroup ov_model_cpp_api
+ */
 template <typename SHAPE_TYPE>
 size_t shape_size(const SHAPE_TYPE& shape) {
     size_t size = 1;
@@ -46,8 +52,11 @@ size_t shape_size(const SHAPE_TYPE& shape) {
     return size;
 }
 
-/// Number of elements in a subset of dimensions of a shape.
-/// Returns a product of dimensions in a range [start_dim;end_dim)
+/**
+ * Number of elements in a subset of dimensions of a shape.
+ * Returns a product of dimensions in a range [start_dim;end_dim)
+ * @ingroup ov_model_cpp_api
+ */
 template <typename ForwardIt>
 size_t shape_size(ForwardIt start_dim, const ForwardIt end_dim) {
     static_assert(std::is_arithmetic<typename std::iterator_traits<ForwardIt>::value_type>::value,

src/core/include/openvino/core/type.hpp

@@ -18,13 +18,16 @@
 
 namespace ov {
 
-/// Supports three functions, ov::is_type<Type>, ov::as_type<Type>, and ov::as_type_ptr<Type> for type-safe
-/// dynamic conversions via static_cast/static_ptr_cast without using C++ RTTI.
-/// Type must have a static type_info member and a virtual get_type_info() member that
-/// returns a reference to its type_info member.
-
-/// Type information for a type system without inheritance; instances have exactly one type not
-/// related to any other type.
+/**
+ * @brief Type information for a type system without inheritance; instances have exactly one type not
+ * related to any other type.
+ *
+ * Supports three functions, ov::is_type<Type>, ov::as_type<Type>, and ov::as_type_ptr<Type> for type-safe
+ * dynamic conversions via static_cast/static_ptr_cast without using C++ RTTI.
+ * Type must have a static type_info member and a virtual get_type_info() member that
+ * returns a reference to its type_info member.
+ * @ingroup ov_model_cpp_api
+ */
 struct OPENVINO_API DiscreteTypeInfo {
     const char* name;
     uint64_t version;

src/core/include/openvino/core/type/element_type.hpp

@@ -22,29 +22,40 @@
 #include "openvino/core/type/bfloat16.hpp"
 #include "openvino/core/type/float16.hpp"
 
+/**
+ * @defgroup ov_element_cpp_api Element types
+ * @ingroup ov_model_cpp_api
+ * OpenVINO Element API to work with OpenVINO element types
+ *
+ */
+
 namespace ov {
 namespace element {
+/// \brief Enum to define possible element types
+/// \ingroup ov_element_cpp_api
 enum class Type_t {
-    undefined,
-    dynamic,
-    boolean,
-    bf16,
-    f16,
-    f32,
-    f64,
-    i4,
-    i8,
-    i16,
-    i32,
-    i64,
-    u1,
-    u4,
-    u8,
-    u16,
-    u32,
-    u64
+    undefined,  //!< Undefined element type
+    dynamic,    //!< Dynamic element type
+    boolean,    //!< boolean element type
+    bf16,       //!< bf16 element type
+    f16,        //!< f16 element type
+    f32,        //!< f32 element type
+    f64,        //!< f64 element type
+    i4,         //!< i4 element type
+    i8,         //!< i8 element type
+    i16,        //!< i16 element type
+    i32,        //!< i32 element type
+    i64,        //!< i64 element type
+    u1,         //!< binary element type
+    u4,         //!< u4 element type
+    u8,         //!< u8 element type
+    u16,        //!< u16 element type
+    u32,        //!< u32 element type
+    u64         //!< u64 element type
 };
 
+/// \brief Base class to define element type
+/// \ingroup ov_element_cpp_api
 class OPENVINO_API Type {
 public:
     Type() = default;
@@ -110,23 +121,59 @@ private:
 
 using TypeVector = std::vector<Type>;
 
+/// \brief undefined element type
+/// \ingroup ov_element_cpp_api
 constexpr Type undefined(Type_t::undefined);
+/// \brief dynamic element type
+/// \ingroup ov_element_cpp_api
 constexpr Type dynamic(Type_t::dynamic);
+/// \brief boolean element type
+/// \ingroup ov_element_cpp_api
 constexpr Type boolean(Type_t::boolean);
+/// \brief bf16 element type
+/// \ingroup ov_element_cpp_api
 constexpr Type bf16(Type_t::bf16);
+/// \brief f16 element type
+/// \ingroup ov_element_cpp_api
 constexpr Type f16(Type_t::f16);
+/// \brief f32 element type
+/// \ingroup ov_element_cpp_api
 constexpr Type f32(Type_t::f32);
+/// \brief f64 element type
+/// \ingroup ov_element_cpp_api
 constexpr Type f64(Type_t::f64);
+/// \brief i4 element type
+/// \ingroup ov_element_cpp_api
 constexpr Type i4(Type_t::i4);
+/// \brief i8 element type
+/// \ingroup ov_element_cpp_api
 constexpr Type i8(Type_t::i8);
+/// \brief i16 element type
+/// \ingroup ov_element_cpp_api
 constexpr Type i16(Type_t::i16);
+/// \brief i32 element type
+/// \ingroup ov_element_cpp_api
 constexpr Type i32(Type_t::i32);
+/// \brief i64 element type
+/// \ingroup ov_element_cpp_api
 constexpr Type i64(Type_t::i64);
+/// \brief binary element type
+/// \ingroup ov_element_cpp_api
 constexpr Type u1(Type_t::u1);
+/// \brief u4 element type
+/// \ingroup ov_element_cpp_api
 constexpr Type u4(Type_t::u4);
+/// \brief u8 element type
+/// \ingroup ov_element_cpp_api
 constexpr Type u8(Type_t::u8);
+/// \brief u16 element type
+/// \ingroup ov_element_cpp_api
 constexpr Type u16(Type_t::u16);
+/// \brief u32 element type
+/// \ingroup ov_element_cpp_api
 constexpr Type u32(Type_t::u32);
+/// \brief u64 element type
+/// \ingroup ov_element_cpp_api
 constexpr Type u64(Type_t::u64);
 
 template <typename T>

src/core/include/openvino/op/abs.hpp

@@ -13,6 +13,7 @@ namespace op {
 namespace v0 {
 /// \brief Elementwise absolute value operation.
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Abs : public util::UnaryElementwiseArithmetic {
 public:
     OPENVINO_OP("Abs", "opset1", util::UnaryElementwiseArithmetic);

src/core/include/openvino/op/acos.hpp

@@ -13,6 +13,7 @@ namespace op {
 namespace v0 {
 /// \brief Elementwise inverse cosine (arccos) operation.
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Acos : public util::UnaryElementwiseArithmetic {
 public:
     OPENVINO_OP("Acos", "opset1", util::UnaryElementwiseArithmetic);

src/core/include/openvino/op/acosh.hpp

@@ -13,6 +13,7 @@ namespace op {
 namespace v3 {
 /// \brief Elementwise inverse hyperbolic cos operation.
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Acosh : public util::UnaryElementwiseArithmetic {
 public:
     OPENVINO_OP("Acosh", "opset4", util::UnaryElementwiseArithmetic, 3);

src/core/include/openvino/op/adaptive_avg_pool.hpp

@@ -12,6 +12,7 @@ namespace op {
 namespace v8 {
 /// \brief Adaptive average pooling operation.
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API AdaptiveAvgPool : public Op {
 public:
     OPENVINO_OP("AdaptiveAvgPool", "opset8");

src/core/include/openvino/op/adaptive_max_pool.hpp

@@ -12,6 +12,7 @@ namespace op {
 namespace v8 {
 /// \brief Adaptive max pooling operation.
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API AdaptiveMaxPool : public Op {
 public:
     OPENVINO_OP("AdaptiveMaxPool", "opset8");

src/core/include/openvino/op/add.hpp

@@ -13,6 +13,7 @@ namespace op {
 namespace v1 {
 /// \brief Elementwise addition operation.
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Add : public util::BinaryElementwiseArithmetic {
 public:
     OPENVINO_OP("Add", "opset1", util::BinaryElementwiseArithmetic, 1);

src/core/include/openvino/op/asin.hpp

@@ -13,6 +13,7 @@ namespace op {
 namespace v0 {
 /// \brief Elementwise inverse sine (arcsin) operation.
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Asin : public util::UnaryElementwiseArithmetic {
 public:
     OPENVINO_OP("Asin", "opset1", util::UnaryElementwiseArithmetic);

src/core/include/openvino/op/assign.hpp

@@ -11,6 +11,7 @@ namespace ov {
 namespace op {
 namespace v3 {
 /// \brief Assign operation sets an input value to the variable with `variable_id`
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Assign : public util::AssignBase {
 public:
     OPENVINO_OP("Assign", "opset3", op::Sink, 3);
@@ -41,6 +42,7 @@ private:
 
 namespace v6 {
 /// \brief Assign operation sets an input value to the variable with `variable_id`
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Assign : public util::AssignBase {
 public:
     OPENVINO_OP("Assign", "opset6", op::Sink, 6);

src/core/include/openvino/op/atan.hpp

@@ -13,6 +13,7 @@ namespace op {
 namespace v0 {
 /// \brief Elementwise inverse tangent (arctan) operation.
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Atan : public util::UnaryElementwiseArithmetic {
 public:
     OPENVINO_OP("Atan", "opset1", util::UnaryElementwiseArithmetic);

src/core/include/openvino/op/atanh.hpp

@@ -13,6 +13,7 @@ namespace op {
 namespace v3 {
 /// \brief Elementwise inverse hyperbolic tangent operation.
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Atanh : public util::UnaryElementwiseArithmetic {
 public:
     OPENVINO_OP("Atanh", "opset4", util::UnaryElementwiseArithmetic, 3);

src/core/include/openvino/op/batch_norm.hpp

@@ -11,6 +11,9 @@
 namespace ov {
 namespace op {
 namespace v0 {
+/// \brief BatchNormInference operation.
+///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API BatchNormInference : public Op {
 public:
     OPENVINO_OP("BatchNormInference", "opset1");
@@ -52,6 +55,9 @@ private:
 };
 }  // namespace v0
 namespace v5 {
+/// \brief BatchNormInference operation.
+///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API BatchNormInference : public Op {
 public:
     OPENVINO_OP("BatchNormInference", "opset5", op::Op, 5);

src/core/include/openvino/op/batch_to_space.hpp

@@ -20,6 +20,7 @@ namespace v1 {
 ///         D_2 * block_shape[2] - crops_begin[2] - crops_end[2], ...,
 ///         D_{N - 1} * block_shape[N - 1] - crops_begin[N - 1] - crops_end[N - 1]`
 ///         of the same type as `data` input.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API BatchToSpace : public Op {
 public:
     OPENVINO_OP("BatchToSpace", "opset2", op::Op, 1);

src/core/include/openvino/op/binary_convolution.hpp

@@ -11,6 +11,9 @@
 namespace ov {
 namespace op {
 namespace v1 {
+/// \brief BinaryConvolution operation.
+///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API BinaryConvolution : public Op {
 public:
     OPENVINO_OP("BinaryConvolution", "opset1", op::Op, 1);

src/core/include/openvino/op/broadcast.hpp

@@ -14,6 +14,7 @@ namespace op {
 namespace v3 {
 /// \brief Operation which "adds" axes to an input tensor, replicating elements from the
 ///        input as needed along the new axes.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Broadcast : public util::BroadcastBase {
 public:
     OPENVINO_OP("Broadcast", "opset3", op::util::BroadcastBase, 3);
@@ -78,6 +79,7 @@ private:
 namespace v1 {
 /// \brief Operation which "adds" axes to an input tensor, replicating elements from the
 ///        input as needed along the new axes.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Broadcast : public util::BroadcastBase {
 public:
     OPENVINO_OP("Broadcast", "opset1", op::util::BroadcastBase, 1);

src/core/include/openvino/op/bucketize.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v3 {
 /// \brief Operation that bucketizes the input based on boundaries
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Bucketize : public Op {
 public:
     OPENVINO_OP("Bucketize", "opset3", op::Op, 3);

src/core/include/openvino/op/ceiling.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v0 {
 /// \brief Elementwise ceiling operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Ceiling : public util::UnaryElementwiseArithmetic {
 public:
     OPENVINO_OP("Ceiling", "opset1", util::UnaryElementwiseArithmetic);

src/core/include/openvino/op/clamp.hpp

@@ -14,6 +14,7 @@ namespace v0 {
 /// All input values that are outside of the <min;max> range are set to 'min' or 'max'
 /// depending on which side of the <min;max> range they are. The values that fall into
 /// this range remain unchanged.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Clamp : public Op {
 public:
     OPENVINO_OP("Clamp", "opset1");

src/core/include/openvino/op/concat.hpp

@@ -12,6 +12,7 @@ namespace ov {
 namespace op {
 namespace v0 {
 /// \brief Concatenation operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Concat : public Op {
 public:
     OPENVINO_OP("Concat", "opset1");

src/core/include/openvino/op/constant.hpp

@@ -19,6 +19,7 @@ namespace ov {
 namespace op {
 namespace v0 {
 /// \brief Class for constants.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Constant : public Op {
 public:
     OPENVINO_OP("Constant", "opset1");

src/core/include/openvino/op/convert.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v0 {
 /// \brief Elementwise type conversion operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Convert : public Op {
 public:
     OPENVINO_OP("Convert", "opset1");

src/core/include/openvino/op/convert_like.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v1 {
 /// \brief Elementwise type conversion operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API ConvertLike : public Op {
 public:
     OPENVINO_OP("ConvertLike", "opset1", op::Op, 1);

src/core/include/openvino/op/convolution.hpp

@@ -13,6 +13,7 @@ namespace op {
 namespace v1 {
 /// \brief Batched convolution operation, with optional window dilation and stride.
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Convolution : public Op {
 public:
     OPENVINO_OP("Convolution", "opset1", op::Op, 1);
@@ -127,6 +128,7 @@ private:
 };
 
 /// \brief Data batch backprop for batched convolution operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API ConvolutionBackpropData : public Op {
 public:
     OPENVINO_OP("ConvolutionBackpropData", "opset1", op::Op, 1);

src/core/include/openvino/op/cos.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v0 {
 /// \brief Elementwise cosine operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Cos : public util::UnaryElementwiseArithmetic {
 public:
     OPENVINO_OP("Cos", "opset1", util::UnaryElementwiseArithmetic);

src/core/include/openvino/op/cosh.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v0 {
 /// \brief Elementwise hyperbolic cosine (cosh) operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Cosh : public util::UnaryElementwiseArithmetic {
 public:
     OPENVINO_OP("Cosh", "opset1", util::UnaryElementwiseArithmetic);

src/core/include/openvino/op/ctc_greedy_decoder.hpp

@@ -9,6 +9,9 @@
 namespace ov {
 namespace op {
 namespace v0 {
+/// \brief CTCGreedyDecoder operation.
+///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API CTCGreedyDecoder : public Op {
 public:
     OPENVINO_OP("CTCGreedyDecoder", "opset1");

src/core/include/openvino/op/ctc_greedy_decoder_seq_len.hpp

@@ -11,6 +11,7 @@ namespace op {
 namespace v6 {
 /// \brief Operator performing CTCGreedyDecoder
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API CTCGreedyDecoderSeqLen : public Op {
 public:
     OPENVINO_OP("CTCGreedyDecoderSeqLen", "opset6", op::Op, 6);

src/core/include/openvino/op/ctc_loss.hpp

@@ -9,6 +9,9 @@
 namespace ov {
 namespace op {
 namespace v4 {
+/// \brief CTCLoss operation.
+///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API CTCLoss : public Op {
 public:
     OPENVINO_OP("CTCLoss", "opset4", op::Op, 4);

src/core/include/openvino/op/cum_sum.hpp

@@ -14,6 +14,7 @@ namespace v0 {
 ///
 /// Compute the cumulative sum of the input tensor along the axis specified.
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API CumSum : public Op {
 public:
     OPENVINO_OP("CumSum", "opset3");

src/core/include/openvino/op/deformable_convolution.hpp

@@ -13,6 +13,7 @@ namespace ov {
 namespace op {
 namespace v1 {
 /// \brief DeformableConvolution operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API DeformableConvolution : public op::util::DeformableConvolutionBase {
 public:
     OPENVINO_OP("DeformableConvolution", "opset1", op::util::DeformableConvolutionBase, 1);
@@ -57,6 +58,9 @@ public:
 }  // namespace v1
 
 namespace v8 {
+/// \brief DeformableConvolution operation.
+///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API DeformableConvolution : public op::util::DeformableConvolutionBase {
 public:
     OPENVINO_OP("DeformableConvolution", "opset8", op::util::DeformableConvolutionBase);

src/core/include/openvino/op/deformable_psroi_pooling.hpp

@@ -9,6 +9,9 @@
 namespace ov {
 namespace op {
 namespace v1 {
+/// \brief DeformablePSROIPooling operation.
+///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API DeformablePSROIPooling : public Op {
 public:
     OPENVINO_OP("DeformablePSROIPooling", "opset1", op::Op, 1);

src/core/include/openvino/op/depth_to_space.hpp

@@ -18,6 +18,7 @@ namespace v0 {
 ///
 ///        Output node produces a tensor with shape:
 ///        [N, C/(blocksize * blocksize), H * blocksize, W * blocksize]
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API DepthToSpace : public Op {
 public:
     OPENVINO_OP("DepthToSpace", "opset1");

src/core/include/openvino/op/dft.hpp

@@ -26,6 +26,7 @@ namespace ov {
 namespace op {
 namespace v7 {
 /// \brief An operation DFT that computes the discrete Fourier transformation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API DFT : public util::FFTBase {
 public:
     OPENVINO_OP("DFT", "opset7", util::FFTBase, 7);

src/core/include/openvino/op/divide.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v1 {
 /// \brief Elementwise division operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Divide : public util::BinaryElementwiseArithmetic {
 public:
     OPENVINO_OP("Divide", "opset1", util::BinaryElementwiseArithmetic, 1);

src/core/include/openvino/op/einsum.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v7 {
 /// \brief Einsum operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Einsum : public Op {
 public:
     OPENVINO_OP("Einsum", "opset7", op::Op, 7);

src/core/include/openvino/op/elu.hpp

@@ -13,6 +13,7 @@ namespace v0 {
 /// x <  0 => f(x) = alpha * (exp(x) - 1.)
 /// x >= 0 => f(x) = x
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Elu : public Op {
 public:
     OPENVINO_OP("Elu", "opset1");

src/core/include/openvino/op/embedding_segments_sum.hpp

@@ -11,6 +11,7 @@ namespace ov {
 namespace op {
 namespace v3 {
 /// \brief Returns embeddings for given indices
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API EmbeddingSegmentsSum : public Op {
 public:
     OPENVINO_OP("EmbeddingSegmentsSum", "opset3", op::Op, 3);

src/core/include/openvino/op/embeddingbag_offsets_sum.hpp

@@ -12,6 +12,7 @@ namespace ov {
 namespace op {
 namespace v3 {
 /// \brief Returns embeddings for given indices
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API EmbeddingBagOffsetsSum : public util::EmbeddingBagOffsetsBase {
 public:
     OPENVINO_OP("EmbeddingBagOffsetsSum", "opset3", util::EmbeddingBagOffsetsBase, 3);

src/core/include/openvino/op/embeddingbag_packedsum.hpp

@@ -12,6 +12,7 @@ namespace ov {
 namespace op {
 namespace v3 {
 /// \brief Returns embeddings for given indices
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API EmbeddingBagPackedSum : public util::EmbeddingBagPackedBase {
 public:
     OPENVINO_OP("EmbeddingBagPackedSum", "opset3", util::EmbeddingBagPackedBase, 3);

src/core/include/openvino/op/equal.hpp

@@ -25,6 +25,7 @@ namespace v1 {
 /// | Type                               | Description                                                                                                                                |
 /// | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
 /// | \f$\texttt{bool}[d_1,\dots,d_n]\f$ | The tensor \f$T\f$, where \f$T[i_1,\dots,i_n] = 1\text{ if }\texttt{arg0}[i_1,\dots,i_n] = \texttt{arg1}[i_1,\dots,i_n]\text{, else } 0\f$ |
+/// \ingroup ov_ops_cpp_api
 // clang-format on
 class OPENVINO_API Equal : public util::BinaryElementwiseComparison {
 public:

src/core/include/openvino/op/erf.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v0 {
 /// \brief Elementwise erf operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Erf : public util::UnaryElementwiseArithmetic {
 public:
     OPENVINO_OP("Erf", "opset1", util::UnaryElementwiseArithmetic);

src/core/include/openvino/op/exp.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v0 {
 /// \brief Elementwise natural exponential (exp) operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Exp : public util::UnaryElementwiseArithmetic {
 public:
     OPENVINO_OP("Exp", "opset1", UnaryElementwiseArithmetic);

src/core/include/openvino/op/experimental_detectron_detection_output.hpp

@@ -17,6 +17,7 @@ namespace v6 {
 /// \brief An operation ExperimentalDetectronDetectionOutput performs
 /// non-maximum suppression to generate the detection output using
 /// information on location and score predictions.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API ExperimentalDetectronDetectionOutput : public Op {
 public:
     OPENVINO_OP("ExperimentalDetectronDetectionOutput", "opset6", op::Op, 6);

src/core/include/openvino/op/experimental_detectron_generate_proposals.hpp

@@ -16,6 +16,7 @@ namespace op {
 namespace v6 {
 /// \brief An operation ExperimentalDetectronGenerateProposalsSingleImage
 /// computes ROIs and their scores based on input data.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API ExperimentalDetectronGenerateProposalsSingleImage : public Op {
 public:
     OPENVINO_OP("ExperimentalDetectronGenerateProposalsSingleImage", "opset6", op::Op, 6);

src/core/include/openvino/op/experimental_detectron_prior_grid_generator.hpp

@@ -16,6 +16,7 @@ namespace op {
 namespace v6 {
 /// \brief An operation ExperimentalDetectronPriorGridGenerator generates prior
 /// grids of specified sizes.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API ExperimentalDetectronPriorGridGenerator : public Op {
 public:
     OPENVINO_OP("ExperimentalDetectronPriorGridGenerator", "opset6", op::Op, 6);

src/core/include/openvino/op/experimental_detectron_roi_feature.hpp

@@ -17,6 +17,7 @@ namespace op {
 namespace v6 {
 /// \brief An operation ExperimentalDetectronROIFeatureExtractor
 /// is the ROIAlign operation applied over a feature pyramid.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API ExperimentalDetectronROIFeatureExtractor : public Op {
 public:
     OPENVINO_OP("ExperimentalDetectronROIFeatureExtractor", "opset6", op::Op, 6);

src/core/include/openvino/op/experimental_detectron_topkrois.hpp

@@ -16,6 +16,7 @@ namespace op {
 namespace v6 {
 /// \brief An operation ExperimentalDetectronTopKROIs, according to the repository
 /// is TopK operation applied to probabilities of input ROIs.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API ExperimentalDetectronTopKROIs : public Op {
 public:
     OPENVINO_OP("ExperimentalDetectronTopKROIs", "opset6", op::Op, 6);

src/core/include/openvino/op/extractimagepatches.hpp

@@ -9,6 +9,9 @@
 namespace ov {
 namespace op {
 namespace v3 {
+/// \brief ExtractImagePatches operation.
+///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API ExtractImagePatches : public Op {
 public:
     OPENVINO_OP("ExtractImagePatches", "opset3", op::Op, 3);

src/core/include/openvino/op/fake_quantize.hpp

@@ -23,6 +23,7 @@ namespace v0 {
 ///                 (levels-1) * (output_high - output_low) + output_low
 ///
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API FakeQuantize : public Op {
 public:
     OPENVINO_OP("FakeQuantize", "opset1");

src/core/include/openvino/op/floor.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v0 {
 /// \brief Elementwise floor operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Floor : public util::UnaryElementwiseArithmetic {
 public:
     OPENVINO_OP("Floor", "opset1", util::UnaryElementwiseArithmetic);

src/core/include/openvino/op/floor_mod.hpp

@@ -11,6 +11,7 @@ namespace op {
 namespace v1 {
 /// \brief Elementwise FloorMod operation.
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API FloorMod : public util::BinaryElementwiseArithmetic {
 public:
     OPENVINO_OP("FloorMod", "opset1", op::util::BinaryElementwiseArithmetic, 1);

src/core/include/openvino/op/gather.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v1 {
 /// \brief Gather slices from axis of data according to indices
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Gather : public op::util::GatherBase {
 public:
     OPENVINO_OP("Gather", "opset1", op::util::GatherBase, 1);
@@ -30,6 +31,7 @@ public:
 
 namespace v7 {
 /// \brief Gather slices from axis of data according to indices
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Gather : public op::util::GatherBase {
 public:
     OPENVINO_OP("Gather", "opset7", op::util::GatherBase, 7);
@@ -57,6 +59,7 @@ public:
 namespace v8 {
 /// \brief Gather slices from axis of data according to indices. Negative indices
 /// are supported and indicate reverse indexing from the end
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Gather : public op::util::GatherBase {
 public:
     OPENVINO_OP("Gather", "opset8", op::util::GatherBase);

src/core/include/openvino/op/gather_elements.hpp

@@ -11,6 +11,7 @@ namespace op {
 namespace v6 {
 /// \brief GatherElements operation
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API GatherElements : public Op {
 public:
     OPENVINO_OP("GatherElements", "opset6", op::Op, 6);

src/core/include/openvino/op/gather_nd.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v5 {
 /// \brief GatherND operation
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API GatherND : public op::util::GatherNDBase {
 public:
     OPENVINO_OP("GatherND", "opset5", op::util::GatherNDBase, 5);
@@ -32,6 +33,7 @@ public:
 namespace v8 {
 /// \brief GatherND operation
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API GatherND : public op::util::GatherNDBase {
 public:
     OPENVINO_OP("GatherND", "opset8", op::util::GatherNDBase);

src/core/include/openvino/op/gather_tree.hpp

@@ -11,6 +11,7 @@ namespace op {
 namespace v1 {
 /// \brief Generates the complete beams from the ids per each step and the parent beam
 /// ids.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API GatherTree : public Op {
 public:
     OPENVINO_OP("GatherTree", "opset1", op::Op, 1);

src/core/include/openvino/op/gelu.hpp

@@ -12,6 +12,7 @@ namespace op {
 namespace v0 {
 /// \brief Gaussian Error Linear Unit
 /// f(x) = 0.5 * x * (1 + erf( x / sqrt(2) )
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Gelu : public Op {
 public:
     OPENVINO_OP("Gelu", "opset2", op::Op, 0);
@@ -40,6 +41,7 @@ namespace v7 {
 /// f(x) = 0.5 * x * (1 + erf( x / sqrt(2) ) for "approximation" = "erf"
 /// f(x) = 0.5 * x * (1 + tanh([sqrt(2 / pi)] * [x + 0.044715^3]) for "approximation" =
 /// "tanh"
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Gelu : public util::UnaryElementwiseArithmetic {
 public:
     OPENVINO_OP("Gelu", "opset7", op::Op, 7);

src/core/include/openvino/op/greater.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v1 {
 /// \brief Elementwise greater-than operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Greater : public util::BinaryElementwiseComparison {
 public:
     OPENVINO_OP("Greater", "opset1", op::util::BinaryElementwiseComparison, 1);

src/core/include/openvino/op/greater_eq.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v1 {
 /// \brief Elementwise greater-than-or-equal operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API GreaterEqual : public util::BinaryElementwiseComparison {
 public:
     OPENVINO_OP("GreaterEqual", "opset1", op::util::BinaryElementwiseComparison, 1);

src/core/include/openvino/op/gru_cell.hpp

@@ -21,6 +21,7 @@ namespace v3 {
 ///
 /// \note       Note this class represents only single *cell* and not whole GRU *layer*.
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API GRUCell : public util::RNNCellBase {
 public:
     OPENVINO_OP("GRUCell", "opset3", op::util::RNNCellBase, 3);

src/core/include/openvino/op/gru_sequence.hpp

@@ -14,6 +14,9 @@
 namespace ov {
 namespace op {
 namespace v5 {
+/// \brief GRUSequence operation.
+///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API GRUSequence : public util::RNNCellBase {
 public:
     OPENVINO_OP("GRUSequence", "opset5", op::Op, 5);

src/core/include/openvino/op/hard_sigmoid.hpp

@@ -12,6 +12,7 @@ namespace v0 {
 /// \brief      Parameterized, bounded sigmoid-like, piecewise linear
 ///             function. min(max(alpha*x + beta, 0), 1)
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API HardSigmoid : public Op {
 public:
     OPENVINO_OP("HardSigmoid", "opset1");

src/core/include/openvino/op/hsigmoid.hpp

@@ -14,6 +14,7 @@ namespace v5 {
 /// f(x) = min(max(x + 3, 0), 6) / 6 or
 /// f(x) = min(ReLU(x + 3), 6) / 6
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API HSigmoid : public util::UnaryElementwiseArithmetic {
 public:
     OPENVINO_OP("HSigmoid", "opset5", op::util::UnaryElementwiseArithmetic, 5);

src/core/include/openvino/op/hswish.hpp

@@ -14,6 +14,7 @@ namespace v4 {
 /// f(x) =  x * min(max(x + 3, 0), 6) / 6 or
 /// f(x) = x * min(ReLU(x + 3), 6) / 6
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API HSwish : public util::UnaryElementwiseArithmetic {
 public:
     OPENVINO_OP("HSwish", "opset4", op::util::UnaryElementwiseArithmetic, 4);

src/core/include/openvino/op/i420_to_bgr.hpp

@@ -30,6 +30,7 @@ namespace v8 {
 ///        B = 1.164 * (Y - 16) + 2.018 * (U - 128)
 ///        Then R, G, B values are clipped to range (0, 255)
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API I420toBGR : public util::ConvertColorI420Base {
 public:
     OPENVINO_OP("I420toBGR", "opset8", util::ConvertColorI420Base);

src/core/include/openvino/op/i420_to_rgb.hpp

@@ -30,6 +30,7 @@ namespace v8 {
 ///        B = 1.164 * (Y - 16) + 2.018 * (U - 128)
 ///        Then R, G, B values are clipped to range (0, 255)
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API I420toRGB : public util::ConvertColorI420Base {
 public:
     OPENVINO_OP("I420toRGB", "opset8", util::ConvertColorI420Base);

src/core/include/openvino/op/idft.hpp

@@ -14,6 +14,7 @@ namespace ov {
 namespace op {
 namespace v7 {
 /// \brief An operation IDFT that computes the inverse discrete Fourier transformation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API IDFT : public util::FFTBase {
 public:
     OPENVINO_OP("IDFT", "opset7", util::FFTBase, 7);

src/core/include/openvino/op/if.hpp

@@ -14,6 +14,7 @@ namespace ov {
 namespace op {
 namespace v8 {
 /// \brief  If operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API If : public util::MultiSubGraphOp {
 public:
     OPENVINO_OP("If", "opset8", MultiSubGraphOp);

src/core/include/openvino/op/interpolate.hpp

@@ -17,6 +17,7 @@ namespace op {
 namespace v0 {
 
 /// \brief Layer which performs bilinear interpolation
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Interpolate : public Op {
 public:
     OPENVINO_OP("Interpolate", "opset1");
@@ -77,6 +78,9 @@ private:
 }  // namespace v0
 
 namespace v4 {
+/// \brief Interpolate operation.
+///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Interpolate : public Op {
 public:
     OPENVINO_OP("Interpolate", "opset4", op::Op, 4);

src/core/include/openvino/op/less.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v1 {
 /// \brief Elementwise less-than operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Less : public util::BinaryElementwiseComparison {
 public:
     OPENVINO_OP("Less", "opset1", op::util::BinaryElementwiseComparison, 1);

src/core/include/openvino/op/less_eq.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v1 {
 /// \brief Elementwise less-than-or-equal operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API LessEqual : public util::BinaryElementwiseComparison {
 public:
     OPENVINO_OP("LessEqual", "opset1", op::util::BinaryElementwiseComparison, 1);

src/core/include/openvino/op/log.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v0 {
 /// \brief Elementwise natural log operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Log : public util::UnaryElementwiseArithmetic {
 public:
     OPENVINO_OP("Log", "opset1", op::util::UnaryElementwiseArithmetic);

src/core/include/openvino/op/log_softmax.hpp

@@ -9,6 +9,9 @@
 namespace ov {
 namespace op {
 namespace v5 {
+/// \brief LogSoftmax operation.
+///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API LogSoftmax : public Op {
 public:
     OPENVINO_OP("LogSoftmax", "opset5", op::Op, 5);

src/core/include/openvino/op/logical_and.hpp

@@ -13,6 +13,7 @@ namespace op {
 namespace v1 {
 /// \brief Elementwise logical-and operation.
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API LogicalAnd : public util::BinaryElementwiseLogical {
 public:
     OPENVINO_OP("LogicalAnd", "opset1", util::BinaryElementwiseLogical, 1);

src/core/include/openvino/op/logical_not.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v1 {
 /// \brief Elementwise logical negation operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API LogicalNot : public Op {
 public:
     OPENVINO_OP("LogicalNot", "opset1", op::Op, 1);

src/core/include/openvino/op/logical_or.hpp

@@ -13,6 +13,7 @@ namespace op {
 namespace v1 {
 /// \brief Elementwise logical-or operation.
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API LogicalOr : public util::BinaryElementwiseLogical {
 public:
     OPENVINO_OP("LogicalOr", "opset1", util::BinaryElementwiseLogical, 1);

src/core/include/openvino/op/logical_xor.hpp

@@ -13,6 +13,7 @@ namespace op {
 namespace v1 {
 /// \brief Elementwise logical-xor operation.
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API LogicalXor : public util::BinaryElementwiseLogical {
 public:
     OPENVINO_OP("LogicalXor", "opset2", util::BinaryElementwiseLogical, 1);

src/core/include/openvino/op/loop.hpp

@@ -15,6 +15,7 @@ namespace ov {
 namespace op {
 namespace v5 {
 /// \brief  Iterate a body over tensors, accumulating into tensors.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Loop : public op::util::SubGraphOp {
 public:
     /// \brief  Allows to define the purpose of inputs/outputs in the body

src/core/include/openvino/op/lrn.hpp

@@ -23,6 +23,7 @@ namespace v0 {
 /// | Type                         | Description                                                                                                                                                                                  |
 /// | ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 /// | \f$N[n, c, d_1,\dots,d_n]\f$ | The tensor \f$T\f$, where \f$T[n, c, d_1,\dots,d_n] = \frac{N[n,i,d_1,\dots,d_n]}{ (bias + alpha * (\sum_{i=max(0,(nsize-1)/2)}^{min(C, (nsize-1)/2)+1} N[n,i,d_1,\dots,d_n]^{2}) ^ {2})}\f$ |
+/// \ingroup ov_ops_cpp_api
 // clang-format on
 class OPENVINO_API LRN : public Op {
 public:

src/core/include/openvino/op/lstm_cell.hpp

@@ -50,6 +50,7 @@ namespace v0 {
 ///
 /// \sa         LSTMSequence, RNNCell, GRUCell
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API LSTMCell : public util::RNNCellBase {
 public:
     OPENVINO_OP("LSTMCell", "opset1", op::util::RNNCellBase);
@@ -273,6 +274,7 @@ namespace v4 {
 ///
 /// \sa         LSTMSequence, RNNCell, GRUCell
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API LSTMCell : public util::RNNCellBase {
 public:
     OPENVINO_OP("LSTMCell", "opset4", op::util::RNNCellBase, 4);

src/core/include/openvino/op/lstm_sequence.hpp

@@ -28,6 +28,7 @@ namespace v0 {
 /// \sa         LSTMCell, RNNCell, GRUCell
 ///
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API LSTMSequence : public Op {
 public:
     OPENVINO_OP("LSTMSequence", "opset1");
@@ -147,6 +148,7 @@ namespace v5 {
 /// \sa         LSTMCell, RNNCell, GRUCell
 ///
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API LSTMSequence : public util::RNNCellBase {
 public:
     OPENVINO_OP("LSTMSequence", "opset5", util::RNNCellBase, 5);

src/core/include/openvino/op/matmul.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v0 {
 /// \brief Operator performing Matrix Multiplication.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API MatMul : public Op {
 public:
     OPENVINO_OP("MatMul", "opset1");

src/core/include/openvino/op/matrix_nms.hpp

@@ -11,6 +11,7 @@ namespace op {
 namespace v8 {
 /// \brief MatrixNms operation
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API MatrixNms : public util::NmsBase {
 public:
     OPENVINO_OP("MatrixNms", "opset8", op::util::NmsBase);

src/core/include/openvino/op/max_pool.hpp

@@ -12,6 +12,7 @@ namespace ov {
 namespace op {
 namespace v1 {
 /// \brief Batched max pooling operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API MaxPool : public op::util::MaxPoolBase {
 public:
     OPENVINO_OP("MaxPool", "opset1", op::util::MaxPoolBase, 1);
@@ -60,6 +61,7 @@ private:
 
 namespace v8 {
 /// \brief MaxPooling operation with values and indices calculated as individual outputs
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API MaxPool : public op::util::MaxPoolBase {
 public:
     OPENVINO_OP("MaxPool", "opset8", op::util::MaxPoolBase);

src/core/include/openvino/op/maximum.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v1 {
 /// \brief Elementwise maximum operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Maximum : public util::BinaryElementwiseArithmetic {
 public:
     OPENVINO_OP("Maximum", "opset1", op::util::BinaryElementwiseArithmetic, 1);

src/core/include/openvino/op/minimum.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v1 {
 /// \brief Elementwise minimum operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Minimum : public util::BinaryElementwiseArithmetic {
 public:
     OPENVINO_OP("Minimum", "opset1", op::util::BinaryElementwiseArithmetic, 1);

src/core/include/openvino/op/mish.hpp

@@ -12,6 +12,7 @@ namespace v4 {
 /// \brief A Self Regularized Non-Monotonic Neural Activation Function
 /// f(x) =  x * tanh(log(exp(x) + 1.))
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Mish : public Op {
 public:
     OPENVINO_OP("Mish", "opset4", op::Op, 4);

src/core/include/openvino/op/mod.hpp

@@ -11,6 +11,7 @@ namespace op {
 namespace v1 {
 /// \brief Mod returns an element-wise division reminder with two given tensors applying
 /// multi-directional broadcast rules.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Mod : public util::BinaryElementwiseArithmetic {
 public:
     OPENVINO_OP("Mod", "opset1", op::util::BinaryElementwiseArithmetic, 1);

src/core/include/openvino/op/multiclass_nms.hpp

@@ -11,6 +11,7 @@ namespace op {
 namespace v8 {
 /// \brief MulticlassNms operation
 ///
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API MulticlassNms : public util::NmsBase {
 public:
     OPENVINO_OP("MulticlassNms", "opset8", op::util::NmsBase);

src/core/include/openvino/op/multiply.hpp

@@ -10,6 +10,7 @@ namespace ov {
 namespace op {
 namespace v1 {
 /// \brief Elementwise multiplication operation.
+/// \ingroup ov_ops_cpp_api
 class OPENVINO_API Multiply : public util::BinaryElementwiseArithmetic {
 public:
     OPENVINO_OP("Multiply", "opset1", util::BinaryElementwiseArithmetic, 1);