Moved cmake functions, variables to API 2.0 naming style (#20281)

* Merge Linux CC + static build + clang compiler * Improvements * Removed ie prefixes from cmake scripts * Fixes for NPU
2023-10-09 22:30:32 +04:00 · 2023-10-09 22:30:32 +04:00 · ead4b8a0ec
commit ead4b8a0ec
parent cba4721cf6
104 changed files with 508 additions and 467 deletions
--- a/.github/workflows/code_style.yml
+++ b/.github/workflows/code_style.yml
@ -60,9 +60,9 @@ jobs:
        run: cmake -B build

      - name: Shellcheck cmake target
-        run: cmake --build build --target ie_shellcheck -j8
+        run: cmake --build build --target ov_shellcheck -j8

-      # always provide suggestions even for skipped scripts in ie_shellcheck tagret
+      # always provide suggestions even for skipped scripts in ov_shellcheck tagret
      - name: ShellCheck action
        if: always()
        uses: reviewdog/action-shellcheck@v1
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -30,7 +30,7 @@ endif()

 project(OpenVINO DESCRIPTION "OpenVINO toolkit")

-find_package(IEDevScripts REQUIRED
+find_package(OpenVINODeveloperScripts REQUIRED
             PATHS "${OpenVINO_SOURCE_DIR}/cmake/developer_package"
             NO_CMAKE_FIND_ROOT_PATH
             NO_DEFAULT_PATH)
@ -162,4 +162,4 @@ endif()
 # provides a callback function to describe each component in repo
 include(cmake/packaging/packaging.cmake)

-ie_cpack(${IE_CPACK_COMPONENTS_ALL})
+ov_cpack(${OV_CPACK_COMPONENTS_ALL})
--- a/cmake/developer_package/OpenVINODeveloperScriptsConfig.cmake
+++ b/cmake/developer_package/OpenVINODeveloperScriptsConfig.cmake
@ -4,10 +4,12 @@

 cmake_minimum_required(VERSION 3.13)

-if(NOT DEFINED IEDevScripts_DIR)
-    message(FATAL_ERROR "IEDevScripts_DIR is not defined")
+if(NOT DEFINED OpenVINODeveloperScripts_DIR )
+    message(FATAL_ERROR "OpenVINODeveloperScripts_DIR  is not defined")
 endif()

+set(IEDevScripts_DIR "${OpenVINODeveloperScripts_DIR}") # for BW compatibility
+
 # disable FindPkgConfig.cmake for Android
 if(ANDROID)
    # Android toolchain does not provide pkg-config file. So, cmake mistakenly uses
@ -23,7 +25,7 @@ macro(ov_set_if_not_defined var value)
 endmacro()

 set(OLD_CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH})
-set(CMAKE_MODULE_PATH "${IEDevScripts_DIR}")
+set(CMAKE_MODULE_PATH "${OpenVINODeveloperScripts_DIR}")

 function(set_ci_build_number)
    set(repo_root "${CMAKE_SOURCE_DIR}")
@ -67,7 +69,7 @@ endif()
 # Prepare temporary folder
 #

-function(set_temp_directory temp_variable source_tree_dir)
+function(ov_set_temp_directory temp_variable source_tree_dir)
    if(DEFINED OV_TEMP)
        message(STATUS "OV_TEMP cmake variable is set : ${OV_TEMP}")
        file(TO_CMAKE_PATH ${OV_TEMP} temp)
@ -84,6 +86,11 @@ function(set_temp_directory temp_variable source_tree_dir)
    endif()
 endfunction()

+macro(set_temp_directory)
+    message(WARNING "'set_temp_directory' is deprecated. Please, use 'ov_set_temp_directory'")
+    ov_set_temp_directory(${ARGV})
+endmacro()
+
 #
 # For cross-compilation
 #
@ -139,37 +146,41 @@ if(NOT DEFINED OUTPUT_ROOT)
 endif()

 # Enable postfixes for Debug/Release builds
-set(IE_DEBUG_POSTFIX_WIN "d")
-set(IE_RELEASE_POSTFIX_WIN "")
-set(IE_DEBUG_POSTFIX_LIN "")
-set(IE_RELEASE_POSTFIX_LIN "")
-set(IE_DEBUG_POSTFIX_MAC "d")
-set(IE_RELEASE_POSTFIX_MAC "")
+set(OV_DEBUG_POSTFIX_WIN "d")
+set(OV_RELEASE_POSTFIX_WIN "")
+set(OV_DEBUG_POSTFIX_LIN "")
+set(OV_RELEASE_POSTFIX_LIN "")
+set(OV_DEBUG_POSTFIX_MAC "d")
+set(OV_RELEASE_POSTFIX_MAC "")

 if(WIN32)
-    set(IE_DEBUG_POSTFIX ${IE_DEBUG_POSTFIX_WIN})
-    set(IE_RELEASE_POSTFIX ${IE_RELEASE_POSTFIX_WIN})
+    set(OV_DEBUG_POSTFIX ${OV_DEBUG_POSTFIX_WIN})
+    set(OV_RELEASE_POSTFIX ${OV_RELEASE_POSTFIX_WIN})
 elseif(APPLE)
-    set(IE_DEBUG_POSTFIX ${IE_DEBUG_POSTFIX_MAC})
-    set(IE_RELEASE_POSTFIX ${IE_RELEASE_POSTFIX_MAC})
+    set(OV_DEBUG_POSTFIX ${OV_DEBUG_POSTFIX_MAC})
+    set(OV_RELEASE_POSTFIX ${OV_RELEASE_POSTFIX_MAC})
 else()
-    set(IE_DEBUG_POSTFIX ${IE_DEBUG_POSTFIX_LIN})
-    set(IE_RELEASE_POSTFIX ${IE_RELEASE_POSTFIX_LIN})
+    set(OV_DEBUG_POSTFIX ${OV_DEBUG_POSTFIX_LIN})
+    set(OV_RELEASE_POSTFIX ${OV_RELEASE_POSTFIX_LIN})
 endif()

-set(CMAKE_DEBUG_POSTFIX ${IE_DEBUG_POSTFIX})
-set(CMAKE_RELEASE_POSTFIX ${IE_RELEASE_POSTFIX})
+set(CMAKE_DEBUG_POSTFIX ${OV_DEBUG_POSTFIX})
+set(CMAKE_RELEASE_POSTFIX ${OV_RELEASE_POSTFIX})

 # Support CMake multi-configuration for Visual Studio / Ninja or Xcode build
 if(OV_GENERATOR_MULTI_CONFIG)
-    set(IE_BUILD_POSTFIX $<$<CONFIG:Debug>:${IE_DEBUG_POSTFIX}>$<$<CONFIG:Release>:${IE_RELEASE_POSTFIX}>)
+    set(OV_BUILD_POSTFIX $<$<CONFIG:Debug>:${OV_DEBUG_POSTFIX}>$<$<CONFIG:Release>:${OV_RELEASE_POSTFIX}>)
 else()
    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-        set(IE_BUILD_POSTFIX ${IE_DEBUG_POSTFIX})
+        set(OV_BUILD_POSTFIX ${OV_DEBUG_POSTFIX})
    else()
-        set(IE_BUILD_POSTFIX ${IE_RELEASE_POSTFIX})
+        set(OV_BUILD_POSTFIX ${OV_RELEASE_POSTFIX})
    endif()
 endif()
+add_definitions(-DOV_BUILD_POSTFIX=\"${OV_BUILD_POSTFIX}\")
+
+# for BW compatibility; removed before 2024.0
+set(IE_BUILD_POSTFIX ${OV_BUILD_POSTFIX})
 add_definitions(-DIE_BUILD_POSTFIX=\"${IE_BUILD_POSTFIX}\")

 ov_set_if_not_defined(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER})
@ -178,11 +189,6 @@ ov_set_if_not_defined(CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FO
 ov_set_if_not_defined(CMAKE_PDB_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER})
 ov_set_if_not_defined(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER})

-if(CPACK_GENERATOR MATCHES "^(DEB|RPM)$")
-    # to make sure that lib/<multiarch-triplet> is created on Debian
-    set(CMAKE_INSTALL_PREFIX "/usr" CACHE PATH "Cmake install prefix" FORCE)
-endif()
-
 include(packaging/packaging)

 if(APPLE)
@ -261,7 +267,7 @@ include(api_validator/api_validator)
 include(vs_version/vs_version)
 include(plugins/plugins)
 include(frontends/frontends)
-include(add_ie_target)
+include(add_target_helpers)
 include(CMakePackageConfigHelpers)

 if(ENABLE_FUZZING)
--- a/cmake/developer_package/add_target_helpers.cmake
+++ b/cmake/developer_package/add_target_helpers.cmake
@ -23,7 +23,7 @@ ov_add_target(
        link_dependencies
   DEPENDENCIES
        dependencies
-        ie::important_plugin
+        openvino::important_plugin
   OBJECT_FILES
        object libraries
   DEFINES
@ -90,8 +90,7 @@ function(ov_add_target)
    source_group("include" FILES ${includes})
    source_group("src"     FILES ${sources})

-    set(all_sources)
-    list(APPEND all_sources ${sources} ${includes} ${ARG_OBJECT_FILES})
+    set(all_sources ${sources} ${includes} ${ARG_OBJECT_FILES})

    # defining a target
    if (ARG_TYPE STREQUAL EXECUTABLE)
@ -102,7 +101,7 @@ function(ov_add_target)
        message(SEND_ERROR "Invalid target type ${ARG_TYPE} specified for target name ${ARG_NAME}")
    endif()

-    ieTargetLinkWholeArchive(${ARG_NAME} ${ARG_LINK_LIBRARIES_WHOLE_ARCHIVE})
+    ov_target_link_whole_archive(${ARG_NAME} ${ARG_LINK_LIBRARIES_WHOLE_ARCHIVE})

    if (ARG_DEFINES)
        target_compile_definitions(${ARG_NAME} PRIVATE ${ARG_DEFINES})
@ -140,11 +139,6 @@ function(ov_add_target)
    endif()
 endfunction()

-function(addIeTarget)
-    message(WARNING "'addIeTarget' is deprecated, please, use 'ov_add_target' instead")
-    ov_add_target(${ARGV})
-endfunction()
-
 #[[
 Wrapper function over addIeTarget, that also adds a test with the same name.
 You could use
@ -195,6 +189,13 @@ function(ov_add_test_target)
            EXCLUDE_FROM_ALL)
 endfunction()

+# deprecated
+
+function(addIeTarget)
+    message(WARNING "'addIeTarget' is deprecated, please, use 'ov_add_target' instead")
+    ov_add_target(${ARGV})
+endfunction()
+
 function(addIeTargetTest)
    message(WARNING "'addIeTargetTest' is deprecated, please, use 'ov_add_test_target' instead")
    ov_add_test_target(${ARGV})
--- a/cmake/developer_package/api_validator/api_validator.cmake
+++ b/cmake/developer_package/api_validator/api_validator.cmake
@ -29,7 +29,7 @@ if(WIN32)
    endif()
 endif()

-function(_ie_add_api_validator_post_build_step_recursive)
+function(_ov_add_api_validator_post_build_step_recursive)
    cmake_parse_arguments(API_VALIDATOR "" "TARGET" "" ${ARGN})

    get_target_property(LIBRARY_TYPE ${API_VALIDATOR_TARGET} TYPE)
@ -55,9 +55,9 @@ function(_ie_add_api_validator_post_build_step_recursive)
                continue()
            endif()
            if(TARGET "${orig_library}")
-                _ie_add_api_validator_post_build_step_recursive(TARGET ${orig_library})
+                _ov_add_api_validator_post_build_step_recursive(TARGET ${orig_library})
            else()
-                _ie_add_api_validator_post_build_step_recursive(TARGET ${library})
+                _ov_add_api_validator_post_build_step_recursive(TARGET ${library})
            endif()
        endif()
    endforeach()
@ -113,10 +113,10 @@ function(_ov_add_api_validator_post_build_step)
    endif()

    # collect targets
-    _ie_add_api_validator_post_build_step_recursive(TARGET ${API_VALIDATOR_TARGET})
+    _ov_add_api_validator_post_build_step_recursive(TARGET ${API_VALIDATOR_TARGET})
    if (API_VALIDATOR_EXTRA)
        foreach(target IN LISTS API_VALIDATOR_EXTRA)
-            _ie_add_api_validator_post_build_step_recursive(TARGET ${target})
+            _ov_add_api_validator_post_build_step_recursive(TARGET ${target})
        endforeach()
    endif()

@ -171,7 +171,7 @@ function(_ov_add_api_validator_post_build_step)
                -D ONECORE_API_VALIDATOR_EXCLUSION=${ONECORE_API_VALIDATOR_EXCLUSION}
                -D ONECORE_API_VALIDATOR_OUTPUT=${output_file}
                -D CMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
-                -P "${IEDevScripts_DIR}/api_validator/api_validator_run.cmake")
+                -P "${OpenVINODeveloperScripts_DIR}/api_validator/api_validator_run.cmake")
        list(APPEND byproducts_files ${output_file})

        unset(target_name)
@ -191,13 +191,15 @@ function(_ov_add_api_validator_post_build_step)
 endfunction()

 #
-# ie_add_api_validator_post_build_step(TARGET <name>)
+# ov_add_api_validator_post_build_step(TARGET <name>)
 #
-macro(ov_add_api_validator_post_build_step)
-    _ov_add_api_validator_post_build_step(${ARGV})
-endmacro()
+function(ov_add_api_validator_post_build_step)
+    _ov_add_api_validator_post_build_step(${ARGN})
+endfunction()

-macro(ie_add_api_validator_post_build_step)
-    message(WARNING "ie_add_api_validator_post_build_step is deprecated, use ov_add_api_validator_post_build_step instead")
-    _ov_add_api_validator_post_build_step(${ARGV})
-endmacro()
+# deprecated
+
+function(ie_add_api_validator_post_build_step)
+    message(WARNING "'ie_add_api_validator_post_build_step' is deprecated, use 'ov_add_api_validator_post_build_step' instead")
+    _ov_add_api_validator_post_build_step(${ARGN})
+endfunction()
--- a/cmake/developer_package/clang_format/clang_format.cmake
+++ b/cmake/developer_package/clang_format/clang_format.cmake
@ -88,10 +88,10 @@ function(ov_add_clang_format_target TARGET_NAME)
            -D "CLANG_FORMAT=${CLANG_FORMAT}"
            -D "INPUT_FILE=${source_file}"
            -D "OUTPUT_FILE=${output_file}"
-            -P "${IEDevScripts_DIR}/clang_format/clang_format_check.cmake"
+            -P "${OpenVINODeveloperScripts_DIR}/clang_format/clang_format_check.cmake"
            DEPENDS
            "${source_file}"
-            "${IEDevScripts_DIR}/clang_format/clang_format_check.cmake"
+            "${OpenVINODeveloperScripts_DIR}/clang_format/clang_format_check.cmake"
            COMMENT
            "[clang-format] ${source_file}"
            VERBATIM)
@ -110,10 +110,10 @@ function(ov_add_clang_format_target TARGET_NAME)
        -D "CLANG_FORMAT=${CLANG_FORMAT}"
        -D "INPUT_FILES=${all_input_sources}"
        -D "EXCLUDE_PATTERNS=${CLANG_FORMAT_EXCLUDE_PATTERNS}"
-        -P "${IEDevScripts_DIR}/clang_format/clang_format_fix.cmake"
+        -P "${OpenVINODeveloperScripts_DIR}/clang_format/clang_format_fix.cmake"
        DEPENDS
        "${all_input_sources}"
-        "${IEDevScripts_DIR}/clang_format/clang_format_fix.cmake"
+        "${OpenVINODeveloperScripts_DIR}/clang_format/clang_format_fix.cmake"
        COMMENT
        "[clang-format] ${TARGET_NAME}_fix"
        VERBATIM)
--- a/cmake/developer_package/compile_flags/os_flags.cmake
+++ b/cmake/developer_package/compile_flags/os_flags.cmake
@ -9,31 +9,31 @@ include(CheckCXXCompilerFlag)
 # ov_disable_deprecated_warnings()
 #
 # Disables deprecated warnings generation in current scope (directory, function)
-# Defines ie_c_cxx_deprecated varaible which contains C / C++ compiler flags
+# Defines ov_c_cxx_deprecated varaible which contains C / C++ compiler flags
 #
 macro(ov_disable_deprecated_warnings)
    if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-        set(ie_c_cxx_deprecated "/wd4996")
+        set(ov_c_cxx_deprecated "/wd4996")
    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
        if(WIN32)
-            set(ie_c_cxx_deprecated "/Qdiag-disable:1478,1786")
+            set(ov_c_cxx_deprecated "/Qdiag-disable:1478,1786")
        else()
-            set(ie_c_cxx_deprecated "-diag-disable=1478,1786")
+            set(ov_c_cxx_deprecated "-diag-disable=1478,1786")
        endif()
    elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX)
-        set(ie_c_cxx_deprecated "-Wno-deprecated-declarations")
+        set(ov_c_cxx_deprecated "-Wno-deprecated-declarations")
    else()
        message(WARNING "Unsupported CXX compiler ${CMAKE_CXX_COMPILER_ID}")
    endif()

-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${ie_c_cxx_deprecated}")
-    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${ie_c_cxx_deprecated}")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ie_c_cxx_deprecated}")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ie_c_cxx_deprecated}")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${ov_c_cxx_deprecated}")
+    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${ov_c_cxx_deprecated}")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ov_c_cxx_deprecated}")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ov_c_cxx_deprecated}")
 endmacro()

 macro(disable_deprecated_warnings)
-    message(WARNING "disable_deprecated_warnings is deprecated, use ov_disable_deprecated_warnings instead")
+    message(WARNING "'disable_deprecated_warnings' is deprecated, use 'ov_disable_deprecated_warnings' instead")
    ov_disable_deprecated_warnings()
 endmacro()

@ -41,30 +41,30 @@ endmacro()
 # ov_deprecated_no_errors()
 #
 # Don't threat deprecated warnings as errors in current scope (directory, function)
-# Defines ie_c_cxx_deprecated_no_errors varaible which contains C / C++ compiler flags
+# Defines ov_c_cxx_deprecated_no_errors varaible which contains C / C++ compiler flags
 #
 macro(ov_deprecated_no_errors)
    if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
        # show 4996 only for /w4
-        set(ie_c_cxx_deprecated_no_errors "/wd4996")
+        set(ov_c_cxx_deprecated_no_errors "/wd4996")
    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
        if(WIN32)
-            set(ie_c_cxx_deprecated_no_errors "/Qdiag-warning:1478,1786")
+            set(ov_c_cxx_deprecated_no_errors "/Qdiag-warning:1478,1786")
        else()
-            set(ie_c_cxx_deprecated_no_errors "-diag-warning=1478,1786")
+            set(ov_c_cxx_deprecated_no_errors "-diag-warning=1478,1786")
        endif()
    elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX)
-        set(ie_c_cxx_deprecated_no_errors "-Wno-error=deprecated-declarations")
+        set(ov_c_cxx_deprecated_no_errors "-Wno-error=deprecated-declarations")
        # Suppress #warning messages
-        set(ie_c_cxx_deprecated_no_errors "${ie_c_cxx_deprecated_no_errors} -Wno-cpp")
+        set(ov_c_cxx_deprecated_no_errors "${ov_c_cxx_deprecated_no_errors} -Wno-cpp")
    else()
        message(WARNING "Unsupported CXX compiler ${CMAKE_CXX_COMPILER_ID}")
    endif()

-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${ie_c_cxx_deprecated_no_errors}")
-    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${ie_c_cxx_deprecated_no_errors}")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ie_c_cxx_deprecated_no_errors}")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ie_c_cxx_deprecated_no_errors}")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${ov_c_cxx_deprecated_no_errors}")
+    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${ov_c_cxx_deprecated_no_errors}")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ov_c_cxx_deprecated_no_errors}")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ov_c_cxx_deprecated_no_errors}")
 endmacro()

 #
@ -74,24 +74,24 @@ endmacro()
 #
 macro(ov_dev_package_no_errors)
    if(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX)
-        set(ie_c_cxx_dev_no_errors "-Wno-all")
+        set(ov_c_cxx_dev_no_errors "-Wno-all")
        if(SUGGEST_OVERRIDE_SUPPORTED)
-            set(ie_cxx_dev_no_errors "-Wno-error=suggest-override")
+            set(ov_cxx_dev_no_errors "-Wno-error=suggest-override")
        endif()
    endif()

-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${ie_c_cxx_dev_no_errors} ${ie_cxx_dev_no_errors}")
-    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${ie_c_cxx_dev_no_errors}")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ie_c_cxx_dev_no_errors} ${ie_cxx_dev_no_errors}")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ie_c_cxx_dev_no_errors}")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${ov_c_cxx_dev_no_errors} ${ov_cxx_dev_no_errors}")
+    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${ov_c_cxx_dev_no_errors}")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ov_c_cxx_dev_no_errors} ${ov_cxx_dev_no_errors}")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ov_c_cxx_dev_no_errors}")
 endmacro()

 #
-# ie_sse42_optimization_flags(<output flags>)
+# ov_sse42_optimization_flags(<output flags>)
 #
 # Provides SSE4.2 compilation flags depending on an OS and a compiler
 #
-macro(ie_sse42_optimization_flags flags)
+macro(ov_sse42_optimization_flags flags)
    if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
        # No such option for MSVC 2019
    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
@ -111,11 +111,11 @@ macro(ie_sse42_optimization_flags flags)
 endmacro()

 #
-# ie_avx2_optimization_flags(<output flags>)
+# ov_avx2_optimization_flags(<output flags>)
 #
 # Provides AVX2 compilation flags depending on an OS and a compiler
 #
-macro(ie_avx2_optimization_flags flags)
+macro(ov_avx2_optimization_flags flags)
    if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
        set(${flags} /arch:AVX2)
    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
@ -132,12 +132,12 @@ macro(ie_avx2_optimization_flags flags)
 endmacro()

 #
-# ie_avx512_optimization_flags(<output flags>)
+# ov_avx512_optimization_flags(<output flags>)
 #
 # Provides common AVX512 compilation flags for AVX512F instruction set support
 # depending on an OS and a compiler
 #
-macro(ie_avx512_optimization_flags flags)
+macro(ov_avx512_optimization_flags flags)
    if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
        set(${flags} /arch:AVX512)
    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
@ -154,9 +154,9 @@ macro(ie_avx512_optimization_flags flags)
 endmacro()

 #
-# ie_arm_neon_optimization_flags(<output flags>)
+# ov_arm_neon_optimization_flags(<output flags>)
 #
-macro(ie_arm_neon_optimization_flags flags)
+macro(ov_arm_neon_optimization_flags flags)
    if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
        message(WARNING "Unsupported CXX compiler ${CMAKE_CXX_COMPILER_ID}")
    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
@ -219,7 +219,7 @@ endfunction()
 # Enables Link Time Optimization compilation
 #
 macro(ie_enable_lto)
-    message(WARNING "ie_add_compiler_flags is deprecated, set INTERPROCEDURAL_OPTIMIZATION_RELEASE target property instead")
+    message(WARNING "'ie_enable_lto' is deprecated, set 'INTERPROCEDURAL_OPTIMIZATION_RELEASE' target property instead")
    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE ON)
 endmacro()

@ -236,7 +236,7 @@ macro(ov_add_compiler_flags)
 endmacro()

 macro(ie_add_compiler_flags)
-    message(WARNING "ie_add_compiler_flags is deprecated, use ov_add_compiler_flags instead")
+    message(WARNING "'ie_add_compiler_flags' is deprecated, use 'ov_add_compiler_flags' instead")
    ov_add_compiler_flags(${ARGN})
 endmacro()

--- a/cmake/developer_package/coverage/coverage.cmake
+++ b/cmake/developer_package/coverage/coverage.cmake
@ -16,7 +16,7 @@ endif()


 set(OV_COVERAGE_REPORTS "${CMAKE_BINARY_DIR}/coverage")
-set(OV_COVERAGE_SCRIPT_DIR "${IEDevScripts_DIR}/coverage")
+set(OV_COVERAGE_SCRIPT_DIR "${OpenVINODeveloperScripts_DIR}/coverage")

 include(CMakeParseArguments)

@ -171,9 +171,9 @@ function(ov_coverage_genhtml)
 endfunction()

 #
-# ie_coverage_remove(INPUT <info_file> OUTPUT <output_file> PATTERNS <patterns ...>)
+# ov_coverage_remove(INPUT <info_file> OUTPUT <output_file> PATTERNS <patterns ...>)
 #
-function(ie_coverage_remove)
+function(ov_coverage_remove)
    cmake_parse_arguments(OV_COVERAGE "" "INPUT;OUTPUT" "PATTERNS" ${ARGN})

    set(input_file "${OV_COVERAGE_REPORTS}/${OV_COVERAGE_INPUT}.info")
@ -199,9 +199,9 @@ function(ie_coverage_remove)
 endfunction()

 #
-# ie_coverage_merge(OUTPUT <output file> INPUTS <input files ...>)
+# ov_coverage_merge(OUTPUT <output file> INPUTS <input files ...>)
 #
-function(ie_coverage_merge)
+function(ov_coverage_merge)
    cmake_parse_arguments(OV_COVERAGE "" "OUTPUT" "INPUTS" ${ARGN})

    set(output_file "${OV_COVERAGE_REPORTS}/${OV_COVERAGE_OUTPUT}.info")
@ -227,6 +227,8 @@ function(ie_coverage_merge)
    add_dependencies(ov_coverage_${OV_COVERAGE_OUTPUT}_info ${dependencies})
 endfunction()

+# deprecated
+
 if(NOT TARGET ie_coverage)
    add_custom_target(ie_coverage)
    set_target_properties(ie_coverage PROPERTIES FOLDER coverage)
--- a/cmake/developer_package/cpplint/cpplint.cmake
+++ b/cmake/developer_package/cpplint/cpplint.cmake
@ -69,17 +69,17 @@ function(add_cpplint_target TARGET_NAME)
            COMMAND
                "${CMAKE_COMMAND}"
                -D "Python3_EXECUTABLE=${Python3_EXECUTABLE}"
-                -D "CPPLINT_SCRIPT=${IEDevScripts_DIR}/cpplint/cpplint.py"
+                -D "CPPLINT_SCRIPT=${OpenVINODeveloperScripts_DIR}/cpplint/cpplint.py"
                -D "INPUT_FILE=${source_file}"
                -D "OUTPUT_FILE=${output_file}"
                -D "WORKING_DIRECTORY=${CMAKE_CURRENT_SOURCE_DIR}"
                -D "SKIP_RETURN_CODE=${ENABLE_CPPLINT_REPORT}"
                -D "CUSTOM_FILTER=${custom_filter}"
-                -P "${IEDevScripts_DIR}/cpplint/cpplint_run.cmake"
+                -P "${OpenVINODeveloperScripts_DIR}/cpplint/cpplint_run.cmake"
            DEPENDS
                "${source_file}"
-                "${IEDevScripts_DIR}/cpplint/cpplint.py"
-                "${IEDevScripts_DIR}/cpplint/cpplint_run.cmake"
+                "${OpenVINODeveloperScripts_DIR}/cpplint/cpplint.py"
+                "${OpenVINODeveloperScripts_DIR}/cpplint/cpplint_run.cmake"
            COMMENT
                "[cpplint] ${source_file_relative_root}"
            VERBATIM)
--- a/cmake/developer_package/cross_compile/cross_compiled_func.cmake
+++ b/cmake/developer_package/cross_compile/cross_compiled_func.cmake
@ -19,9 +19,9 @@ set(_DEFINE_AVX2     "HAVE_AVX2"    ${_DEFINE_AVX})
 set(_DEFINE_AVX512F  "HAVE_AVX512F" ${_DEFINE_AVX2})

 ## Arch specific compile options
-ie_avx512_optimization_flags(_FLAGS_AVX512F)
-ie_avx2_optimization_flags  (_FLAGS_AVX2)
-ie_sse42_optimization_flags (_FLAGS_SSE42)
+ov_avx512_optimization_flags(_FLAGS_AVX512F)
+ov_avx2_optimization_flags  (_FLAGS_AVX2)
+ov_sse42_optimization_flags (_FLAGS_SSE42)
 set(_FLAGS_AVX "")  ## TBD is not defined for IE project yet
 set(_FLAGS_ANY "")  ##

--- a/cmake/developer_package/faster_build.cmake
+++ b/cmake/developer_package/faster_build.cmake
@ -20,6 +20,8 @@ function(ov_build_target_faster TARGET_NAME)
    endif()
 endfunction()

+# deprecated
+
 function(ie_faster_build)
    message(WARNING "ie_faster_build is deprecated, use ov_build_target_faster instead")
    ov_build_target_faster(${ARGV})
--- a/cmake/developer_package/features.cmake
+++ b/cmake/developer_package/features.cmake
@ -6,19 +6,19 @@ include(options)
 include(target_flags)

 set (CPACK_GENERATOR "TGZ" CACHE STRING "Cpack generator for OpenVINO")
-list (APPEND IE_OPTIONS CPACK_GENERATOR)
+list (APPEND OV_OPTIONS CPACK_GENERATOR)

 # FIXME: there are compiler failures with LTO and Cross-Compile toolchains. Disabling for now, but
 #        this must be addressed in a proper way
-ie_dependent_option (ENABLE_LTO "Enable Link Time Optimization" OFF
+ov_dependent_option (ENABLE_LTO "Enable Link Time Optimization" OFF
    "LINUX;EMSCRIPTEN OR NOT CMAKE_CROSSCOMPILING;CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.9" OFF)

-ie_option (OS_FOLDER "create OS dedicated folder in output" OFF)
+ov_option (OS_FOLDER "create OS dedicated folder in output" OFF)

 if(OV_GENERATOR_MULTI_CONFIG)
-    ie_option(USE_BUILD_TYPE_SUBFOLDER "Create dedicated sub-folder per build type for output binaries" OFF)
+    ov_option(USE_BUILD_TYPE_SUBFOLDER "Create dedicated sub-folder per build type for output binaries" OFF)
 else()
-    ie_option(USE_BUILD_TYPE_SUBFOLDER "Create dedicated sub-folder per build type for output binaries" ON)
+    ov_option(USE_BUILD_TYPE_SUBFOLDER "Create dedicated sub-folder per build type for output binaries" ON)
 endif()

 if(DEFINED ENV{CI_BUILD_NUMBER} AND NOT (WIN32 OR CMAKE_CROSSCOMPILING))
@ -27,37 +27,37 @@ else()
    set(CMAKE_COMPILE_WARNING_AS_ERROR_DEFAULT OFF)
 endif()

-ie_option (CMAKE_COMPILE_WARNING_AS_ERROR "Enable warnings as errors" ${CMAKE_COMPILE_WARNING_AS_ERROR_DEFAULT})
+ov_option (CMAKE_COMPILE_WARNING_AS_ERROR "Enable warnings as errors" ${CMAKE_COMPILE_WARNING_AS_ERROR_DEFAULT})

-ie_dependent_option (ENABLE_QSPECTRE "Enable Qspectre mitigation" OFF "CMAKE_CXX_COMPILER_ID STREQUAL MSVC" OFF)
+ov_dependent_option (ENABLE_QSPECTRE "Enable Qspectre mitigation" OFF "CMAKE_CXX_COMPILER_ID STREQUAL MSVC" OFF)

-ie_dependent_option (ENABLE_INTEGRITYCHECK "build DLLs with /INTEGRITYCHECK flag" OFF "CMAKE_CXX_COMPILER_ID STREQUAL MSVC" OFF)
+ov_dependent_option (ENABLE_INTEGRITYCHECK "build DLLs with /INTEGRITYCHECK flag" OFF "CMAKE_CXX_COMPILER_ID STREQUAL MSVC" OFF)

-ie_option (ENABLE_SANITIZER "enable checking memory errors via AddressSanitizer" OFF)
+ov_option (ENABLE_SANITIZER "enable checking memory errors via AddressSanitizer" OFF)

-ie_option (ENABLE_UB_SANITIZER "enable UndefinedBahavior sanitizer" OFF)
+ov_option (ENABLE_UB_SANITIZER "enable UndefinedBahavior sanitizer" OFF)

-ie_option (ENABLE_THREAD_SANITIZER "enable checking data races via ThreadSanitizer" OFF)
+ov_option (ENABLE_THREAD_SANITIZER "enable checking data races via ThreadSanitizer" OFF)

-ie_dependent_option (ENABLE_COVERAGE "enable code coverage" OFF "CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG" OFF)
+ov_dependent_option (ENABLE_COVERAGE "enable code coverage" OFF "CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG" OFF)

 # Defines CPU capabilities

-ie_dependent_option (ENABLE_SSE42 "Enable SSE4.2 optimizations" ON "X86_64 OR (X86 AND NOT EMSCRIPTEN)" OFF)
+ov_dependent_option (ENABLE_SSE42 "Enable SSE4.2 optimizations" ON "X86_64 OR (X86 AND NOT EMSCRIPTEN)" OFF)

-ie_dependent_option (ENABLE_AVX2 "Enable AVX2 optimizations" ON "X86_64 OR (X86 AND NOT EMSCRIPTEN)" OFF)
+ov_dependent_option (ENABLE_AVX2 "Enable AVX2 optimizations" ON "X86_64 OR (X86 AND NOT EMSCRIPTEN)" OFF)

-ie_dependent_option (ENABLE_AVX512F "Enable AVX512 optimizations" ON "X86_64 OR (X86 AND NOT EMSCRIPTEN)" OFF)
+ov_dependent_option (ENABLE_AVX512F "Enable AVX512 optimizations" ON "X86_64 OR (X86 AND NOT EMSCRIPTEN)" OFF)

 # Type of build, we add this as an explicit option to default it to ON
 get_property(BUILD_SHARED_LIBS_DEFAULT GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS)
-ie_option (BUILD_SHARED_LIBS "Build as a shared library" ${BUILD_SHARED_LIBS_DEFAULT})
+ov_option (BUILD_SHARED_LIBS "Build as a shared library" ${BUILD_SHARED_LIBS_DEFAULT})

 # Android does not support SOVERSION
 # see https://www.opengis.ch/2011/11/23/creating-non-versioned-shared-libraries-for-android/
-ie_dependent_option (ENABLE_LIBRARY_VERSIONING "Enable libraries versioning" ON "NOT WIN32;NOT ANDROID;BUILD_SHARED_LIBS" OFF)
+ov_dependent_option (ENABLE_LIBRARY_VERSIONING "Enable libraries versioning" ON "NOT WIN32;NOT ANDROID;BUILD_SHARED_LIBS" OFF)

-ie_dependent_option (ENABLE_FASTER_BUILD "Enable build features (PCH, UNITY) to speed up build time" OFF "CMAKE_VERSION VERSION_GREATER_EQUAL 3.16" OFF)
+ov_dependent_option (ENABLE_FASTER_BUILD "Enable build features (PCH, UNITY) to speed up build time" OFF "CMAKE_VERSION VERSION_GREATER_EQUAL 3.16" OFF)

 if(CMAKE_CROSSCOMPILING OR WIN32)
    set(STYLE_CHECKS_DEFAULT OFF)
@ -65,22 +65,22 @@ else()
    set(STYLE_CHECKS_DEFAULT ON)
 endif()

-ie_option (ENABLE_CPPLINT "Enable cpplint checks during the build" ${STYLE_CHECKS_DEFAULT})
+ov_option (ENABLE_CPPLINT "Enable cpplint checks during the build" ${STYLE_CHECKS_DEFAULT})

-ie_dependent_option (ENABLE_CPPLINT_REPORT "Build cpplint report instead of failing the build" OFF "ENABLE_CPPLINT" OFF)
+ov_dependent_option (ENABLE_CPPLINT_REPORT "Build cpplint report instead of failing the build" OFF "ENABLE_CPPLINT" OFF)

-ie_option (ENABLE_CLANG_FORMAT "Enable clang-format checks during the build" ${STYLE_CHECKS_DEFAULT})
+ov_option (ENABLE_CLANG_FORMAT "Enable clang-format checks during the build" ${STYLE_CHECKS_DEFAULT})

-ie_option (ENABLE_NCC_STYLE "Enable ncc style check" ${STYLE_CHECKS_DEFAULT})
+ov_option (ENABLE_NCC_STYLE "Enable ncc style check" ${STYLE_CHECKS_DEFAULT})

-ie_option (ENABLE_UNSAFE_LOCATIONS "skip check for MD5 for dependency" OFF)
+ov_option (ENABLE_UNSAFE_LOCATIONS "skip check for MD5 for dependency" OFF)

 if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND MSVC_VERSION GREATER_EQUAL 1930)
    # Visual Studio 2022: 1930-1939 = VS 17.0 (v143 toolset)
    set(_msvc_version_2022 ON)
 endif()

-ie_dependent_option (ENABLE_FUZZING "instrument build for fuzzing" OFF "OV_COMPILER_IS_CLANG OR _msvc_version_2022" OFF)
+ov_dependent_option (ENABLE_FUZZING "instrument build for fuzzing" OFF "OV_COMPILER_IS_CLANG OR _msvc_version_2022" OFF)

 #
 # Check features
--- a/cmake/developer_package/frontends/frontends.cmake
+++ b/cmake/developer_package/frontends/frontends.cmake
@ -38,7 +38,7 @@ function(ov_generate_frontends_hpp)
    ov_target_link_frontends(openvino)

    set(ov_frontends_hpp "${CMAKE_BINARY_DIR}/src/frontends/common/src/ov_frontends.hpp")
-    set(frontends_hpp_in "${IEDevScripts_DIR}/frontends/ov_frontends.hpp.in")
+    set(frontends_hpp_in "${OpenVINODeveloperScripts_DIR}/frontends/ov_frontends.hpp.in")

    add_custom_command(OUTPUT "${ov_frontends_hpp}"
                       COMMAND
@ -46,10 +46,10 @@ function(ov_generate_frontends_hpp)
                        -D "OV_FRONTENDS_HPP_HEADER_IN=${frontends_hpp_in}"
                        -D "OV_FRONTENDS_HPP_HEADER=${ov_frontends_hpp}"
                        -D "FRONTEND_NAMES=${FRONTEND_NAMES}"
-                        -P "${IEDevScripts_DIR}/frontends/create_frontends_hpp.cmake"
+                        -P "${OpenVINODeveloperScripts_DIR}/frontends/create_frontends_hpp.cmake"
                       DEPENDS
                         "${frontends_hpp_in}"
-                         "${IEDevScripts_DIR}/frontends/create_frontends_hpp.cmake"
+                         "${OpenVINODeveloperScripts_DIR}/frontends/create_frontends_hpp.cmake"
                       COMMENT
                         "Generate ov_frontends.hpp for static build"
                       VERBATIM)
--- a/cmake/developer_package/ncc_naming_style/ncc_naming_style.cmake
+++ b/cmake/developer_package/ncc_naming_style/ncc_naming_style.cmake
@ -6,7 +6,7 @@ if(NOT COMMAND ov_check_pip_packages)
    message(FATAL_ERROR "Internal error: ncc_naming_style.cmake must be included after ov_check_pip_packages")
 endif()

-set(ncc_style_dir "${IEDevScripts_DIR}/ncc_naming_style")
+set(ncc_style_dir "${OpenVINODeveloperScripts_DIR}/ncc_naming_style")
 set(ncc_style_bin_dir "${CMAKE_CURRENT_BINARY_DIR}/ncc_naming_style")

 # find python3
--- a/cmake/developer_package/options.cmake
+++ b/cmake/developer_package/options.cmake
@ -2,46 +2,47 @@
 # SPDX-License-Identifier: Apache-2.0
 #

-# Usage: ie_option(<option_variable> "description" <initial value or boolean expression> [IF <condition>])
-
 include (CMakeDependentOption)

 if(POLICY CMP0127)
    cmake_policy(SET CMP0127 NEW)
 endif()

-macro (ie_option variable description value)
+macro(ov_option variable description value)
    option(${variable} "${description}" ${value})
+    list(APPEND OV_OPTIONS ${variable})
    list(APPEND IE_OPTIONS ${variable})
 endmacro()

-# Usage: ov_option(<option_variable> "description" <initial value or boolean expression> [IF <condition>])
-macro (ov_option variable description value)
-    ie_option(${variable} "${description}" ${value})
-endmacro()
-
-macro (ie_dependent_option variable description def_value condition fallback_value)
+macro(ov_dependent_option variable description def_value condition fallback_value)
    cmake_dependent_option(${variable} "${description}" ${def_value} "${condition}" ${fallback_value})
+    list(APPEND OV_OPTIONS ${variable})
    list(APPEND IE_OPTIONS ${variable})
 endmacro()

-macro (ie_option_enum variable description value)
+macro(ov_option_enum variable description value)
    set(OPTIONS)
    set(ONE_VALUE_ARGS)
    set(MULTI_VALUE_ARGS ALLOWED_VALUES)
-    cmake_parse_arguments(IE_OPTION_ENUM "${OPTIONS}" "${ONE_VALUE_ARGS}" "${MULTI_VALUE_ARGS}" ${ARGN})
+    cmake_parse_arguments(OPTION_ENUM "${OPTIONS}" "${ONE_VALUE_ARGS}" "${MULTI_VALUE_ARGS}" ${ARGN})

-    if(NOT ${value} IN_LIST IE_OPTION_ENUM_ALLOWED_VALUES)
-        message(FATAL_ERROR "variable must be one of ${IE_OPTION_ENUM_ALLOWED_VALUES}")
+    if(NOT ${value} IN_LIST OPTION_ENUM_ALLOWED_VALUES)
+        message(FATAL_ERROR "Internal error: variable must be one of ${OPTION_ENUM_ALLOWED_VALUES}")
    endif()

+    list(APPEND OV_OPTIONS ${variable})
    list(APPEND IE_OPTIONS ${variable})

    set(${variable} ${value} CACHE STRING "${description}")
-    set_property(CACHE ${variable} PROPERTY STRINGS ${IE_OPTION_ENUM_ALLOWED_VALUES})
+    set_property(CACHE ${variable} PROPERTY STRINGS ${OPTION_ENUM_ALLOWED_VALUES})
+
+    unset(OPTIONS)
+    unset(ONE_VALUE_ARGS)
+    unset(MULTI_VALUE_ARGS)
+    unset(OPTION_ENUM_ALLOWED_VALUES)
 endmacro()

-function (print_enabled_features)
+function (ov_print_enabled_features)
    if(NOT COMMAND set_ci_build_number)
        message(FATAL_ERROR "CI_BUILD_NUMBER is not set yet")
    endif()
@ -49,8 +50,25 @@ function (print_enabled_features)
    message(STATUS "OpenVINO Runtime enabled features: ")
    message(STATUS "")
    message(STATUS "    CI_BUILD_NUMBER: ${CI_BUILD_NUMBER}")
-    foreach(_var ${IE_OPTIONS})
+    foreach(_var IN LISTS OV_OPTIONS)
        message(STATUS "    ${_var} = ${${_var}}")
    endforeach()
    message(STATUS "")
 endfunction()
+
+# deprecated
+
+macro (ie_option variable description value)
+    message(WARNING "'ie_option' is deprecated, please, use 'ov_option' instead")
+    ov_option(${variable} "${description}" ${value})
+endmacro()
+
+macro(ie_dependent_option variable description def_value condition fallback_value)
+    message(WARNING "'ie_dependent_option' is deprecated, please, use 'ov_dependent_option' instead")
+    ov_dependent_option(${variable} "${description}" ${def_value} "${condition}" ${fallback_value})
+endmacro()
+
+function(print_enabled_features)
+    message(WARNING "'print_enabled_features' is deprecated, please, use 'ov_print_enabled_features' instead")
+    ov_print_enabled_features()
+endfunction()
--- a/cmake/developer_package/packaging/archive.cmake
+++ b/cmake/developer_package/packaging/archive.cmake
@ -44,11 +44,6 @@ macro(ov_archive_cpack_set_dirs)
        set(OV_CPACK_ARCHIVEDIR runtime/lib/${ARCH_FOLDER})
    endif()
    set(OV_CPACK_PLUGINSDIR ${OV_CPACK_RUNTIMEDIR})
-
-    # for BW compatibility
-    set(IE_CPACK_LIBRARY_PATH ${OV_CPACK_LIBRARYDIR})
-    set(IE_CPACK_RUNTIME_PATH ${OV_CPACK_RUNTIMEDIR})
-    set(IE_CPACK_ARCHIVE_PATH ${OV_CPACK_ARCHIVEDIR})
 endmacro()

 ov_archive_cpack_set_dirs()
--- a/cmake/developer_package/packaging/common-libraries.cmake
+++ b/cmake/developer_package/packaging/common-libraries.cmake
@ -47,11 +47,6 @@ macro(ov_common_libraries_cpack_set_dirs)

    # skipped during common libraries packaging
    set(OV_CPACK_WHEELSDIR "tools")
-
-    # for BW compatibility
-    set(IE_CPACK_LIBRARY_PATH ${OV_CPACK_LIBRARYDIR})
-    set(IE_CPACK_RUNTIME_PATH ${OV_CPACK_RUNTIMEDIR})
-    set(IE_CPACK_ARCHIVE_PATH ${OV_CPACK_ARCHIVEDIR})
 endmacro()

 ov_common_libraries_cpack_set_dirs()
--- a/cmake/developer_package/packaging/debian/debian.cmake
+++ b/cmake/developer_package/packaging/debian/debian.cmake
@ -45,11 +45,6 @@ macro(ov_debian_cpack_set_dirs)

    # skipped during debian packaging
    set(OV_CPACK_WHEELSDIR "tools")
-
-    # for BW compatibility
-    set(IE_CPACK_LIBRARY_PATH ${OV_CPACK_RUNTIMEDIR})
-    set(IE_CPACK_RUNTIME_PATH ${OV_CPACK_RUNTIMEDIR})
-    set(IE_CPACK_ARCHIVE_PATH ${OV_CPACK_ARCHIVEDIR})
 endmacro()

 ov_debian_cpack_set_dirs()
@ -134,7 +129,9 @@ macro(ov_debian_specific_settings)
    # homepage
    set(CPACK_DEBIAN_PACKAGE_HOMEPAGE "https://docs.openvino.ai/")
    # use lintian to check packages in post-build step
-    set(CPACK_POST_BUILD_SCRIPTS "${IEDevScripts_DIR}/packaging/debian/post_build.cmake")
+    set(CPACK_POST_BUILD_SCRIPTS "${OpenVINODeveloperScripts_DIR}/packaging/debian/post_build.cmake")
+    # to make sure that lib/<multiarch-triplet> is created on Debian
+    set(CMAKE_INSTALL_PREFIX "/usr" CACHE PATH "Cmake install prefix" FORCE)
    # enable for debug cpack run
    if(NOT DEFINED CPACK_DEBIAN_PACKAGE_DEBUG)
        set(CPACK_DEBIAN_PACKAGE_DEBUG OFF)
--- a/cmake/developer_package/packaging/nsis.cmake
+++ b/cmake/developer_package/packaging/nsis.cmake
@ -83,11 +83,6 @@ macro(ov_archive_cpack_set_dirs)
        set(OV_CPACK_ARCHIVEDIR runtime/lib/${ARCH_FOLDER})
    endif()
    set(OV_CPACK_PLUGINSDIR ${OV_CPACK_RUNTIMEDIR})
-
-    # for BW compatibility
-    set(IE_CPACK_LIBRARY_PATH ${OV_CPACK_LIBRARYDIR})
-    set(IE_CPACK_RUNTIME_PATH ${OV_CPACK_RUNTIMEDIR})
-    set(IE_CPACK_ARCHIVE_PATH ${OV_CPACK_ARCHIVEDIR})
 endmacro()

 ov_nsis_cpack_set_dirs()
--- a/cmake/developer_package/packaging/packaging.cmake
+++ b/cmake/developer_package/packaging/packaging.cmake
@ -49,22 +49,22 @@ endfunction()
 # Wraps original `cpack_add_component` and adds component to internal IE list
 #
 function(ov_cpack_add_component name)
-    if(NOT ${name} IN_LIST IE_CPACK_COMPONENTS_ALL)
+    if(NOT ${name} IN_LIST OV_CPACK_COMPONENTS_ALL)
        cpack_add_component(${name} ${ARGN})

        # need to store informarion about cpack_add_component arguments in CMakeCache.txt
        # to restore it later
        set(_${name}_cpack_component_args "${ARGN}" CACHE INTERNAL "Argument for cpack_add_component for ${name} cpack component" FORCE)

-        list(APPEND IE_CPACK_COMPONENTS_ALL ${name})
-        set(IE_CPACK_COMPONENTS_ALL "${IE_CPACK_COMPONENTS_ALL}" CACHE INTERNAL "" FORCE)
+        list(APPEND OV_CPACK_COMPONENTS_ALL ${name})
+        set(OV_CPACK_COMPONENTS_ALL "${OV_CPACK_COMPONENTS_ALL}" CACHE INTERNAL "" FORCE)
    endif()
 endfunction()

-foreach(comp IN LISTS IE_CPACK_COMPONENTS_ALL)
+foreach(comp IN LISTS OV_CPACK_COMPONENTS_ALL)
    unset(_${comp}_cpack_component_args)
 endforeach()
-unset(IE_CPACK_COMPONENTS_ALL CACHE)
+unset(OV_CPACK_COMPONENTS_ALL CACHE)

 # create `tests` component
 if(ENABLE_TESTS)
@ -164,7 +164,7 @@ elseif(CPACK_GENERATOR MATCHES "^(7Z|TBZ2|TGZ|TXZ|TZ|TZST|ZIP)$")
    include(packaging/archive)
 endif()

-macro(ie_cpack)
+macro(ov_cpack)
    set(CPACK_SOURCE_GENERATOR "") # not used
    set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "OpenVINO™ Toolkit")
    set(CPACK_COMPONENT_UNSPECIFIED_REQUIRED OFF)
@ -223,3 +223,10 @@ macro(ie_cpack)

    include(CPack)
 endmacro()
+
+# deprecated
+
+macro(ie_cpack)
+    message(WARNING "'ie_cpack' is deprecated. Please, use 'ov_cpack'")
+    ov_cpack(${ARGV})
+endmacro()
--- a/cmake/developer_package/packaging/rpm/rpm.cmake
+++ b/cmake/developer_package/packaging/rpm/rpm.cmake
@ -36,11 +36,6 @@ macro(ov_rpm_cpack_set_dirs)

    # skipped during rpm packaging
    set(OV_CPACK_WHEELSDIR "tools")
-
-    # for BW compatibility
-    set(IE_CPACK_LIBRARY_PATH ${OV_CPACK_LIBRARYDIR})
-    set(IE_CPACK_RUNTIME_PATH ${OV_CPACK_RUNTIMEDIR})
-    set(IE_CPACK_ARCHIVE_PATH ${OV_CPACK_ARCHIVEDIR})
 endmacro()

 ov_rpm_cpack_set_dirs()
@ -128,7 +123,7 @@ macro(ov_rpm_specific_settings)
    # TODO: fix "error: bad date in %changelog"
    # set(CPACK_RPM_CHANGELOG_FILE "${OpenVINO_SOURCE_DIR}/cmake/developer_package/packaging/rpm/changelog")
    # use rpmlint to check packages in post-build step
-    set(CPACK_POST_BUILD_SCRIPTS "${IEDevScripts_DIR}/packaging/rpm/post_build.cmake")
+    set(CPACK_POST_BUILD_SCRIPTS "${OpenVINODeveloperScripts_DIR}/packaging/rpm/post_build.cmake")
    # enable for debug cpack run
    ov_set_if_not_defined(CPACK_RPM_PACKAGE_DEBUG OFF)

--- a/cmake/developer_package/plugins/plugins.cmake
+++ b/cmake/developer_package/plugins/plugins.cmake
@ -8,7 +8,7 @@ set(PLUGIN_FILES "" CACHE INTERNAL "")

 function(ov_plugin_get_file_name target_name library_name)
    set(LIB_PREFIX "${CMAKE_SHARED_MODULE_PREFIX}")
-    set(LIB_SUFFIX "${IE_BUILD_POSTFIX}${CMAKE_SHARED_MODULE_SUFFIX}")
+    set(LIB_SUFFIX "${OV_BUILD_POSTFIX}${CMAKE_SHARED_MODULE_SUFFIX}")

    get_target_property(LIB_NAME ${target_name} OUTPUT_NAME)
    if (LIB_NAME STREQUAL "LIB_NAME-NOTFOUND")
@ -168,6 +168,7 @@ function(ov_add_plugin)
 endfunction()

 function(ie_add_plugin)
+    message(WARNING "'ie_add_plugin' is deprecated. Please, use 'ov_add_plugin'")
    ov_add_plugin(${ARGN})
 endfunction()

@ -203,7 +204,7 @@ macro(ov_register_in_plugins_xml)
                    -D "OV_CONFIG_OUTPUT_FILE=${config_output_file}"
                    -D "OV_PLUGIN_NAME=${device_name}"
                    -D "OV_CONFIGS_DIR=${CMAKE_BINARY_DIR}/plugins"
-                    -P "${IEDevScripts_DIR}/plugins/unregister_plugin_cmake.cmake"
+                    -P "${OpenVINODeveloperScripts_DIR}/plugins/unregister_plugin_cmake.cmake"
                  COMMENT
                    "Remove ${device_name} from the plugins.xml file"
                  VERBATIM)
@ -232,7 +233,7 @@ macro(ov_register_in_plugins_xml)
              -D "OV_DEVICE_NAME=${device_name}"
              -D "OV_PLUGIN_PROPERTIES=${${device_name}_CONFIG}"
              -D "OV_PLUGIN_LIBRARY_NAME=${library_name}"
-              -P "${IEDevScripts_DIR}/plugins/create_plugin_file.cmake"
+              -P "${OpenVINODeveloperScripts_DIR}/plugins/create_plugin_file.cmake"
          COMMENT "Register ${device_name} device as ${library_name}"
          VERBATIM)

@ -247,7 +248,7 @@ macro(ov_register_in_plugins_xml)
                          -D "CMAKE_SHARED_MODULE_PREFIX=${CMAKE_SHARED_MODULE_PREFIX}"
                          -D "OV_CONFIG_OUTPUT_FILE=${config_output_file}"
                          -D "OV_CONFIGS_DIR=${CMAKE_BINARY_DIR}/plugins"
-                          -P "${IEDevScripts_DIR}/plugins/register_plugin_cmake.cmake"
+                          -P "${OpenVINODeveloperScripts_DIR}/plugins/register_plugin_cmake.cmake"
                        COMMENT
                          "Registering plugins to plugins.xml config file"
                        VERBATIM)
@ -266,6 +267,7 @@ endmacro()
 # ie_register_plugins()
 #
 macro(ie_register_plugins)
+    message(WARNING "'ie_register_plugins' is deprecated. Please, use 'ov_register_plugins'")
    ov_register_plugins(${ARGN})
 endmacro()

@ -346,7 +348,7 @@ function(ov_generate_plugins_hpp)
    else()
        set(ov_plugins_hpp "${CMAKE_BINARY_DIR}/src/inference/ov_plugins.hpp")
    endif()
-    set(plugins_hpp_in "${IEDevScripts_DIR}/plugins/plugins.hpp.in")
+    set(plugins_hpp_in "${OpenVINODeveloperScripts_DIR}/plugins/plugins.hpp.in")

    add_custom_command(OUTPUT "${ov_plugins_hpp}"
                       COMMAND
@ -357,10 +359,10 @@ function(ov_generate_plugins_hpp)
                        -D "OV_PLUGINS_HPP_HEADER=${ov_plugins_hpp}"
                        ${device_configs}
                        ${as_extension}
-                        -P "${IEDevScripts_DIR}/plugins/create_plugins_hpp.cmake"
+                        -P "${OpenVINODeveloperScripts_DIR}/plugins/create_plugins_hpp.cmake"
                       DEPENDS
                         "${plugins_hpp_in}"
-                         "${IEDevScripts_DIR}/plugins/create_plugins_hpp.cmake"
+                         "${OpenVINODeveloperScripts_DIR}/plugins/create_plugins_hpp.cmake"
                       COMMENT
                         "Generate ov_plugins.hpp"
                       VERBATIM)
--- a/cmake/developer_package/plugins/unregister_plugin_cmake.cmake
+++ b/cmake/developer_package/plugins/unregister_plugin_cmake.cmake
@ -7,7 +7,7 @@ if(NOT EXISTS "${OV_CONFIG_OUTPUT_FILE}")
 endif()

 # remove plugin file
-file(REMOVE "${OV_CONFIGS_DIR}/${IE_PLUGIN_NAME}.xml")
+file(REMOVE "${OV_CONFIGS_DIR}/${OV_PLUGIN_NAME}.xml")

 # remove plugin
 set(newContent "")
@ -15,7 +15,7 @@ file(STRINGS "${OV_CONFIG_OUTPUT_FILE}" content)

 set(skip_plugin OFF)
 foreach(line IN LISTS content)
-    if("${line}" MATCHES "name=\"${IE_PLUGIN_NAME}\"")
+    if("${line}" MATCHES "name=\"${OV_PLUGIN_NAME}\"")
        set(skip_plugin ON)
    endif()

--- a/cmake/developer_package/python_requirements.cmake
+++ b/cmake/developer_package/python_requirements.cmake
@ -103,7 +103,7 @@ function(ov_check_pip_packages)
 from check_python_requirements import check_python_requirements ;
 check_python_requirements('${ARG_REQUIREMENTS_FILE}') ;
            "
-            WORKING_DIRECTORY "${IEDevScripts_DIR}"
+            WORKING_DIRECTORY "${OpenVINODeveloperScripts_DIR}"
            RESULT_VARIABLE EXIT_CODE
            OUTPUT_VARIABLE OUTPUT_TEXT
            ERROR_VARIABLE ERROR_TEXT)
--- a/cmake/developer_package/shellcheck/shellcheck.cmake
+++ b/cmake/developer_package/shellcheck/shellcheck.cmake
@ -17,20 +17,20 @@ if(shellcheck_PROGRAM)
    endif()
 endif()

-function(ie_shellcheck_process)
+function(ov_shellcheck_process)
    if(NOT shellcheck_PROGRAM)
        message(WARNING "shellcheck tool is not found")
        return()
    endif()

-    cmake_parse_arguments(IE_SHELLCHECK "" "DIRECTORY" "SKIP" ${ARGN})
+    cmake_parse_arguments(SHELLCHECK "" "DIRECTORY" "SKIP" ${ARGN})

-    set(IE_SHELLCHECK_SCRIPT "${IEDevScripts_DIR}/shellcheck/shellcheck_process.cmake")
-    file(GLOB_RECURSE scripts "${IE_SHELLCHECK_DIRECTORY}/*.sh")
+    set(SHELLCHECK_SCRIPT "${OpenVINODeveloperScripts_DIR}/shellcheck/shellcheck_process.cmake")
+    file(GLOB_RECURSE scripts "${SHELLCHECK_DIRECTORY}/*.sh")
    foreach(script IN LISTS scripts)
        # check if we need to skip scripts
        unset(skip_script)
-        foreach(skip_directory IN LISTS IE_SHELLCHECK_SKIP)
+        foreach(skip_directory IN LISTS SHELLCHECK_SKIP)
            if(script MATCHES "${skip_directory}/*")
                set(skip_script ON)
            endif()
@ -39,21 +39,21 @@ function(ie_shellcheck_process)
            continue()
        endif()

-        string(REPLACE "${IE_SHELLCHECK_DIRECTORY}" "${CMAKE_BINARY_DIR}/shellcheck" output_file ${script})
+        string(REPLACE "${SHELLCHECK_DIRECTORY}" "${CMAKE_BINARY_DIR}/shellcheck" output_file ${script})
        set(output_file "${output_file}.txt")
        get_filename_component(script_name "${script}" NAME)

        add_custom_command(OUTPUT ${output_file}
                           COMMAND ${CMAKE_COMMAND}
-                             -D IE_SHELLCHECK_PROGRAM=${shellcheck_PROGRAM}
-                             -D IE_SHELL_SCRIPT=${script}
-                             -D IE_SHELLCHECK_OUTPUT=${output_file}
-                             -P ${IE_SHELLCHECK_SCRIPT}
-                           DEPENDS ${script} ${IE_SHELLCHECK_SCRIPT}
+                             -D SHELLCHECK_PROGRAM=${shellcheck_PROGRAM}
+                             -D SHELL_SCRIPT=${script}
+                             -D SHELLCHECK_OUTPUT=${output_file}
+                             -P ${SHELLCHECK_SCRIPT}
+                           DEPENDS ${script} ${SHELLCHECK_SCRIPT}
                           COMMENT "Check script ${script_name}"
                           VERBATIM)
        list(APPEND outputs ${output_file})
    endforeach()

-    add_custom_target(ie_shellcheck DEPENDS ${outputs})
+    add_custom_target(ov_shellcheck DEPENDS ${outputs})
 endfunction()
--- a/cmake/developer_package/shellcheck/shellcheck_process.cmake
+++ b/cmake/developer_package/shellcheck/shellcheck_process.cmake
@ -2,25 +2,19 @@
 # SPDX-License-Identifier: Apache-2.0
 #

-if(NOT DEFINED IE_SHELLCHECK_PROGRAM)
-    message(FATAL_ERROR "IE_SHELLCHECK_PROGRAM is not defined")
-endif()
-
-if(NOT DEFINED IE_SHELL_SCRIPT)
-    message(FATAL_ERROR "IE_SHELL_SCRIPT is not defined")
-endif()
-
-if(NOT DEFINED IE_SHELLCHECK_OUTPUT)
-    message(FATAL_ERROR "IE_SHELLCHECK_OUTPUT is not defined")
-endif()
+foreach(var SHELLCHECK_PROGRAM SHELL_SCRIPT SHELLCHECK_OUTPUT)
+    if(NOT DEFINED ${var})
+        message(FATAL_ERROR "${var} is not defined")
+    endif()
+endforeach()

 set(rules "SC1091,SC2164,SC2162,SC1090")
-execute_process(COMMAND ${IE_SHELLCHECK_PROGRAM} --exclude=${rules} ${IE_SHELL_SCRIPT}
+execute_process(COMMAND ${SHELLCHECK_PROGRAM} --exclude=${rules} ${SHELL_SCRIPT}
                OUTPUT_VARIABLE error_message
                RESULT_VARIABLE exit_code
                OUTPUT_STRIP_TRAILING_WHITESPACE)

-file(WRITE "${IE_SHELLCHECK_OUTPUT}" "${error_message}")
+file(WRITE "${SHELLCHECK_OUTPUT}" "${error_message}")

 if(NOT exit_code EQUAL 0)
    message(FATAL_ERROR "${error_message}")
--- a/cmake/developer_package/tbb/TBBConfig.cmake
+++ b/cmake/developer_package/tbb/TBBConfig.cmake
@ -14,13 +14,13 @@

 # Path to IE own version of TBBConfig.cmake old TBB version without cmake config.
 if(APPLE)
-    set(IE_OWN_TBB_CONFIG tbb/mac)
+    set(_OV_OWN_TBB_CONFIG tbb/mac)
 elseif(UNIX)
-    set(IE_OWN_TBB_CONFIG tbb/lnx)
+    set(_OV_OWN_TBB_CONFIG tbb/lnx)
 elseif(WIN)
-    set(IE_OWN_TBB_CONFIG tbb/win)
+    set(_OV_OWN_TBB_CONFIG tbb/win)
 else()
-    unset(IE_OWN_TBB_CONFIG)
+    unset(_OV_OWN_TBB_CONFIG)
 endif()

 unset(TBB_DIR)
@ -29,8 +29,10 @@ unset(TBB_DIR CACHE)
 find_package(TBB
    2017.0
    CONFIG
-    PATHS "${IEDevScripts_DIR}/${IE_OWN_TBB_CONFIG}"
+    PATHS "${OpenVINODeveloperScripts_DIR}/${_OV_OWN_TBB_CONFIG}"
    NO_DEFAULT_PATH
    NO_CMAKE_FIND_ROOT_PATH)

 find_package_handle_standard_args(TBB CONFIG_MODE)
+
+unset(_OV_OWN_TBB_CONFIG)
--- a/cmake/developer_package/version.cmake
+++ b/cmake/developer_package/version.cmake
@ -166,6 +166,8 @@ endif()
 ov_parse_ci_build_number()

 macro (addVersionDefines FILE)
+    message(WARNING "'addVersionDefines' is deprecated. Please, use 'ov_add_version_defines'")
+
    set(__version_file ${FILE})
    if(NOT IS_ABSOLUTE ${__version_file})
        set(__version_file "${CMAKE_CURRENT_SOURCE_DIR}/${__version_file}")
--- a/cmake/developer_package/vs_version/vs_version.cmake
+++ b/cmake/developer_package/vs_version/vs_version.cmake
@ -73,7 +73,7 @@ function(ov_add_vs_version_file)
    set(OV_VS_VER_INTERNALNAME_STR ${VS_VER_NAME})

    set(vs_version_output "${CMAKE_CURRENT_BINARY_DIR}/vs_version.rc")
-    configure_file("${IEDevScripts_DIR}/vs_version/vs_version.rc.in" "${vs_version_output}" @ONLY)
+    configure_file("${OpenVINODeveloperScripts_DIR}/vs_version/vs_version.rc.in" "${vs_version_output}" @ONLY)

    source_group("src" FILES ${vs_version_output})
    target_sources(${VS_VER_NAME} PRIVATE ${vs_version_output})
--- a/cmake/developer_package/whole_archive.cmake
+++ b/cmake/developer_package/whole_archive.cmake
@ -5,15 +5,14 @@
 #[[
 function links static library without removing any symbol from it.

-ieTargetLinkWholeArchive(<target name> <lib1> [<lib2> ...])
+ov_target_link_whole_archive(<target name> <lib1> [<lib2> ...])
 Example:
-ieTargetLinkWholeArchive("FunctionalTests" "CommonLib" "AnotherLib")
+ov_target_link_whole_archive("FunctionalTests" "CommonLib" "AnotherLib")

 #]]

-function(ieTargetLinkWholeArchive targetName)
-    set(libs)
-    foreach(staticLib ${ARGN})
+function(ov_target_link_whole_archive targetName)
+    foreach(staticLib IN LISTS ARGN)
        if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
            # CMake does not support generator expression in LINK_FLAGS, so we workaround it a little bit:
            # passing same static library as normal link (to get build deps working, and includes too), than using WHOLEARCHIVE option
@ -52,3 +51,10 @@ function(ieTargetLinkWholeArchive targetName)
        target_link_libraries(${targetName} PRIVATE ${libs})
    endif()
 endfunction()
+
+# deprecated
+
+function(ieTargetLinkWholeArchive)
+    message(WARNING "'ieTargetLinkWholeArchive' is deprecated, use 'ov_target_link_whole_archive' instead")
+    ov_target_link_whole_archive(${ARGN})
+endfunction()
--- a/cmake/features.cmake
+++ b/cmake/features.cmake
@ -14,12 +14,12 @@ else()
    set(ENABLE_INTEL_CPU_DEFAULT ON)
 endif()

-ie_dependent_option (ENABLE_INTEL_CPU "CPU plugin for OpenVINO Runtime" ${ENABLE_INTEL_CPU_DEFAULT}
+ov_dependent_option (ENABLE_INTEL_CPU "CPU plugin for OpenVINO Runtime" ${ENABLE_INTEL_CPU_DEFAULT}
    "RISCV64 OR X86 OR X86_64 OR AARCH64 OR ARM" OFF)

-ie_dependent_option (ENABLE_ARM_COMPUTE_CMAKE "Enable ARM Compute build via cmake" OFF "ENABLE_INTEL_CPU" OFF)
+ov_dependent_option (ENABLE_ARM_COMPUTE_CMAKE "Enable ARM Compute build via cmake" OFF "ENABLE_INTEL_CPU" OFF)

-ie_option (ENABLE_TESTS "unit, behavior and functional tests" OFF)
+ov_option (ENABLE_TESTS "unit, behavior and functional tests" OFF)

 if(ENABLE_TESTS)
    include(CTest)
@ -32,7 +32,7 @@ else()
    set(ENABLE_INTEL_GPU_DEFAULT OFF)
 endif()

-ie_dependent_option (ENABLE_INTEL_GPU "GPU OpenCL-based plugin for OpenVINO Runtime" ${ENABLE_INTEL_GPU_DEFAULT} "X86_64 OR AARCH64;NOT APPLE;NOT WINDOWS_STORE;NOT WINDOWS_PHONE" OFF)
+ov_dependent_option (ENABLE_INTEL_GPU "GPU OpenCL-based plugin for OpenVINO Runtime" ${ENABLE_INTEL_GPU_DEFAULT} "X86_64 OR AARCH64;NOT APPLE;NOT WINDOWS_STORE;NOT WINDOWS_PHONE" OFF)

 if (ANDROID OR MINGW OR (CMAKE_COMPILER_IS_GNUCXX AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.0) OR (NOT BUILD_SHARED_LIBS AND ENABLE_INTEL_CPU))
    # oneDNN doesn't support old compilers and android builds for now, so we'll build GPU plugin without oneDNN
@ -42,31 +42,31 @@ else()
    set(ENABLE_ONEDNN_FOR_GPU_DEFAULT ON)
 endif()

-ie_dependent_option (ENABLE_ONEDNN_FOR_GPU "Enable oneDNN with GPU support" ${ENABLE_ONEDNN_FOR_GPU_DEFAULT} "ENABLE_INTEL_GPU" OFF)
+ov_dependent_option (ENABLE_ONEDNN_FOR_GPU "Enable oneDNN with GPU support" ${ENABLE_ONEDNN_FOR_GPU_DEFAULT} "ENABLE_INTEL_GPU" OFF)

-ie_option (ENABLE_DEBUG_CAPS "enable OpenVINO debug capabilities at runtime" OFF)
-ie_dependent_option (ENABLE_GPU_DEBUG_CAPS "enable GPU debug capabilities at runtime" ON "ENABLE_DEBUG_CAPS;ENABLE_INTEL_GPU" OFF)
-ie_dependent_option (ENABLE_CPU_DEBUG_CAPS "enable CPU debug capabilities at runtime" ON "ENABLE_DEBUG_CAPS;ENABLE_INTEL_CPU" OFF)
+ov_option (ENABLE_DEBUG_CAPS "enable OpenVINO debug capabilities at runtime" OFF)
+ov_dependent_option (ENABLE_GPU_DEBUG_CAPS "enable GPU debug capabilities at runtime" ON "ENABLE_DEBUG_CAPS;ENABLE_INTEL_GPU" OFF)
+ov_dependent_option (ENABLE_CPU_DEBUG_CAPS "enable CPU debug capabilities at runtime" ON "ENABLE_DEBUG_CAPS;ENABLE_INTEL_CPU" OFF)

-ie_option (ENABLE_PROFILING_ITT "Build with ITT tracing. Optionally configure pre-built ittnotify library though INTEL_VTUNE_DIR variable." OFF)
+ov_option (ENABLE_PROFILING_ITT "Build with ITT tracing. Optionally configure pre-built ittnotify library though INTEL_VTUNE_DIR variable." OFF)

-ie_option_enum(ENABLE_PROFILING_FILTER "Enable or disable ITT counter groups.\
+ov_option_enum(ENABLE_PROFILING_FILTER "Enable or disable ITT counter groups.\
 Supported values:\
 ALL - enable all ITT counters (default value)\
 FIRST_INFERENCE - enable only first inference time counters" ALL
               ALLOWED_VALUES ALL FIRST_INFERENCE)

-ie_option (ENABLE_PROFILING_FIRST_INFERENCE "Build with ITT tracing of first inference time." ON)
+ov_option (ENABLE_PROFILING_FIRST_INFERENCE "Build with ITT tracing of first inference time." ON)

-ie_option_enum(SELECTIVE_BUILD "Enable OpenVINO conditional compilation or statistics collection. \
+ov_option_enum(SELECTIVE_BUILD "Enable OpenVINO conditional compilation or statistics collection. \
 In case SELECTIVE_BUILD is enabled, the SELECTIVE_BUILD_STAT variable should contain the path to the collected IntelSEAPI statistics. \
 Usage: -DSELECTIVE_BUILD=ON -DSELECTIVE_BUILD_STAT=/path/*.csv" OFF
               ALLOWED_VALUES ON OFF COLLECT)

-ie_option (ENABLE_DOCS "Build docs using Doxygen" OFF)
+ov_option (ENABLE_DOCS "Build docs using Doxygen" OFF)

 find_package(PkgConfig QUIET)
-ie_dependent_option (ENABLE_PKGCONFIG_GEN "Enable openvino.pc pkg-config file generation" ON "LINUX OR APPLE;PkgConfig_FOUND;BUILD_SHARED_LIBS" OFF)
+ov_dependent_option (ENABLE_PKGCONFIG_GEN "Enable openvino.pc pkg-config file generation" ON "LINUX OR APPLE;PkgConfig_FOUND;BUILD_SHARED_LIBS" OFF)

 #
 # OpenVINO Runtime specific options
@ -82,7 +82,7 @@ endif()

 set(THREADING "${THREADING_DEFAULT}" CACHE STRING "Threading")
 set_property(CACHE THREADING PROPERTY STRINGS "TBB" "TBB_AUTO" "OMP" "SEQ")
-list (APPEND IE_OPTIONS THREADING)
+list (APPEND OV_OPTIONS THREADING)
 if (NOT THREADING STREQUAL "TBB" AND
    NOT THREADING STREQUAL "TBB_AUTO" AND
    NOT THREADING STREQUAL "OMP" AND
@ -97,50 +97,50 @@ else()
    set(ENABLE_TBBBIND_2_5_DEFAULT OFF)
 endif()

-ie_dependent_option (ENABLE_TBBBIND_2_5 "Enable TBBBind_2_5 static usage in OpenVINO runtime" ${ENABLE_TBBBIND_2_5_DEFAULT} "THREADING MATCHES TBB; NOT APPLE" OFF)
-ie_dependent_option (ENABLE_TBB_RELEASE_ONLY "Only Release TBB libraries are linked to the OpenVINO Runtime binaries" ON "THREADING MATCHES TBB;LINUX" OFF)
+ov_dependent_option (ENABLE_TBBBIND_2_5 "Enable TBBBind_2_5 static usage in OpenVINO runtime" ${ENABLE_TBBBIND_2_5_DEFAULT} "THREADING MATCHES TBB; NOT APPLE" OFF)
+ov_dependent_option (ENABLE_TBB_RELEASE_ONLY "Only Release TBB libraries are linked to the OpenVINO Runtime binaries" ON "THREADING MATCHES TBB;LINUX" OFF)

-ie_dependent_option (ENABLE_INTEL_GNA "GNA support for OpenVINO Runtime" ON
+ov_dependent_option (ENABLE_INTEL_GNA "GNA support for OpenVINO Runtime" ON
    "NOT APPLE;NOT ANDROID;X86_64;CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 5.4" OFF)

-ie_dependent_option (ENABLE_INTEL_GNA_DEBUG "GNA debug build" OFF "ENABLE_INTEL_GNA" OFF)
-ie_dependent_option (ENABLE_V7_SERIALIZE "enables serialization to IR v7" OFF "ENABLE_INTEL_GNA" OFF)
-ie_dependent_option (ENABLE_IR_V7_READER "Enables IR v7 reader" ${BUILD_SHARED_LIBS} "ENABLE_TESTS;ENABLE_INTEL_GNA" OFF)
+ov_dependent_option (ENABLE_INTEL_GNA_DEBUG "GNA debug build" OFF "ENABLE_INTEL_GNA" OFF)
+ov_dependent_option (ENABLE_V7_SERIALIZE "enables serialization to IR v7" OFF "ENABLE_INTEL_GNA" OFF)
+ov_dependent_option (ENABLE_IR_V7_READER "Enables IR v7 reader" ${BUILD_SHARED_LIBS} "ENABLE_TESTS;ENABLE_INTEL_GNA" OFF)

-ie_dependent_option (ENABLE_GAPI_PREPROCESSING "Enables G-API preprocessing" ON "NOT MINGW64" OFF)
+ov_dependent_option (ENABLE_GAPI_PREPROCESSING "Enables G-API preprocessing" ON "NOT MINGW64" OFF)

-ie_option (ENABLE_MULTI "Enables MULTI Device Plugin" ON)
-ie_option (ENABLE_AUTO "Enables AUTO Device Plugin" ON)
-ie_option (ENABLE_AUTO_BATCH "Enables Auto-Batching Plugin" ON)
-ie_option (ENABLE_HETERO "Enables Hetero Device Plugin" ON)
-ie_option (ENABLE_TEMPLATE "Enable template plugin" ON)
+ov_option (ENABLE_MULTI "Enables MULTI Device Plugin" ON)
+ov_option (ENABLE_AUTO "Enables AUTO Device Plugin" ON)
+ov_option (ENABLE_AUTO_BATCH "Enables Auto-Batching Plugin" ON)
+ov_option (ENABLE_HETERO "Enables Hetero Device Plugin" ON)
+ov_option (ENABLE_TEMPLATE "Enable template plugin" ON)

-ie_dependent_option (ENABLE_PLUGINS_XML "Generate plugins.xml configuration file or not" OFF "BUILD_SHARED_LIBS" OFF)
+ov_dependent_option (ENABLE_PLUGINS_XML "Generate plugins.xml configuration file or not" OFF "BUILD_SHARED_LIBS" OFF)

-ie_dependent_option (GAPI_TEST_PERF "if GAPI unit tests should examine performance" OFF "ENABLE_TESTS;ENABLE_GAPI_PREPROCESSING" OFF)
+ov_dependent_option (GAPI_TEST_PERF "if GAPI unit tests should examine performance" OFF "ENABLE_TESTS;ENABLE_GAPI_PREPROCESSING" OFF)

-ie_dependent_option (ENABLE_FUNCTIONAL_TESTS "functional tests" ON "ENABLE_TESTS" OFF)
+ov_dependent_option (ENABLE_FUNCTIONAL_TESTS "functional tests" ON "ENABLE_TESTS" OFF)

-ie_option (ENABLE_SAMPLES "console samples are part of OpenVINO Runtime package" ON)
+ov_option (ENABLE_SAMPLES "console samples are part of OpenVINO Runtime package" ON)

 set(OPENVINO_EXTRA_MODULES "" CACHE STRING "Extra paths for extra modules to include into OpenVINO build")

 find_host_package(Python3 QUIET COMPONENTS Interpreter)
 if(Python3_Interpreter_FOUND)
-    ie_option(ENABLE_OV_ONNX_FRONTEND "Enable ONNX FrontEnd" ON)
+    ov_option(ENABLE_OV_ONNX_FRONTEND "Enable ONNX FrontEnd" ON)
 else()
-    ie_option(ENABLE_OV_ONNX_FRONTEND "Enable ONNX FrontEnd" OFF)
+    ov_option(ENABLE_OV_ONNX_FRONTEND "Enable ONNX FrontEnd" OFF)
 endif()
-ie_option(ENABLE_OV_PADDLE_FRONTEND "Enable PaddlePaddle FrontEnd" ON)
-ie_option(ENABLE_OV_IR_FRONTEND "Enable IR FrontEnd" ON)
-ie_option(ENABLE_OV_PYTORCH_FRONTEND "Enable PyTorch FrontEnd" ON)
-ie_option(ENABLE_OV_IR_FRONTEND "Enable IR FrontEnd" ON)
-ie_option(ENABLE_OV_TF_FRONTEND "Enable TensorFlow FrontEnd" ON)
-ie_option(ENABLE_OV_TF_LITE_FRONTEND "Enable TensorFlow Lite FrontEnd" ON)
-ie_dependent_option(ENABLE_SNAPPY_COMPRESSION "Enables compression support for TF FE" ON
+ov_option(ENABLE_OV_PADDLE_FRONTEND "Enable PaddlePaddle FrontEnd" ON)
+ov_option(ENABLE_OV_IR_FRONTEND "Enable IR FrontEnd" ON)
+ov_option(ENABLE_OV_PYTORCH_FRONTEND "Enable PyTorch FrontEnd" ON)
+ov_option(ENABLE_OV_IR_FRONTEND "Enable IR FrontEnd" ON)
+ov_option(ENABLE_OV_TF_FRONTEND "Enable TensorFlow FrontEnd" ON)
+ov_option(ENABLE_OV_TF_LITE_FRONTEND "Enable TensorFlow Lite FrontEnd" ON)
+ov_dependent_option(ENABLE_SNAPPY_COMPRESSION "Enables compression support for TF FE" ON
    "ENABLE_OV_TF_FRONTEND" OFF)

-ie_dependent_option (ENABLE_STRICT_DEPENDENCIES "Skip configuring \"convinient\" dependencies for efficient parallel builds" ON "ENABLE_TESTS;ENABLE_OV_ONNX_FRONTEND" OFF)
+ov_dependent_option (ENABLE_STRICT_DEPENDENCIES "Skip configuring \"convinient\" dependencies for efficient parallel builds" ON "ENABLE_TESTS;ENABLE_OV_ONNX_FRONTEND" OFF)

 if(CMAKE_HOST_LINUX AND LINUX)
    # Debian packages are enabled on Ubuntu systems
@ -175,28 +175,28 @@ else()
    set(ENABLE_SYSTEM_TBB_DEFAULT ${ENABLE_SYSTEM_LIBS_DEFAULT})
 endif()

-ie_dependent_option (ENABLE_SYSTEM_TBB  "Enables use of system TBB" ${ENABLE_SYSTEM_TBB_DEFAULT}
+ov_dependent_option (ENABLE_SYSTEM_TBB  "Enables use of system TBB" ${ENABLE_SYSTEM_TBB_DEFAULT}
    "THREADING MATCHES TBB" OFF)
 # TODO: turn it off by default during the work on cross-os distribution, because pugixml is not
 # available out of box on all systems (like RHEL, UBI)
-ie_option (ENABLE_SYSTEM_PUGIXML "Enables use of system PugiXML" ${ENABLE_SYSTEM_PUGIXML_DEFAULT})
+ov_option (ENABLE_SYSTEM_PUGIXML "Enables use of system PugiXML" ${ENABLE_SYSTEM_PUGIXML_DEFAULT})
 # the option is on by default, because we use only flatc compiler and don't use any libraries
-ie_dependent_option(ENABLE_SYSTEM_FLATBUFFERS "Enables use of system flatbuffers" ${ENABLE_SYSTEM_FLATBUFFERS_DEFAULT}
+ov_dependent_option(ENABLE_SYSTEM_FLATBUFFERS "Enables use of system flatbuffers" ${ENABLE_SYSTEM_FLATBUFFERS_DEFAULT}
    "ENABLE_OV_TF_LITE_FRONTEND" OFF)
-ie_dependent_option (ENABLE_SYSTEM_OPENCL "Enables use of system OpenCL" ${ENABLE_SYSTEM_LIBS_DEFAULT}
+ov_dependent_option (ENABLE_SYSTEM_OPENCL "Enables use of system OpenCL" ${ENABLE_SYSTEM_LIBS_DEFAULT}
    "ENABLE_INTEL_GPU" OFF)
 # the option is turned off by default, because we compile our own static version of protobuf
 # with LTO and -fPIC options, while system one does not have such flags
-ie_dependent_option (ENABLE_SYSTEM_PROTOBUF "Enables use of system Protobuf" OFF
+ov_dependent_option (ENABLE_SYSTEM_PROTOBUF "Enables use of system Protobuf" OFF
    "ENABLE_OV_ONNX_FRONTEND OR ENABLE_OV_PADDLE_FRONTEND OR ENABLE_OV_TF_FRONTEND" OFF)
 # the option is turned off by default, because we don't want to have a dependency on libsnappy.so
-ie_dependent_option (ENABLE_SYSTEM_SNAPPY "Enables use of system version of Snappy" OFF
+ov_dependent_option (ENABLE_SYSTEM_SNAPPY "Enables use of system version of Snappy" OFF
    "ENABLE_SNAPPY_COMPRESSION" OFF)

-ie_dependent_option (ENABLE_PYTHON_PACKAGING "Enables packaging of Python API in APT / YUM" OFF
+ov_dependent_option (ENABLE_PYTHON_PACKAGING "Enables packaging of Python API in APT / YUM" OFF
    "ENABLE_PYTHON;UNIX" OFF)

-ie_option(ENABLE_OPENVINO_DEBUG "Enable output for OPENVINO_DEBUG statements" OFF)
+ov_option(ENABLE_OPENVINO_DEBUG "Enable output for OPENVINO_DEBUG statements" OFF)

 if(NOT BUILD_SHARED_LIBS AND ENABLE_OV_TF_FRONTEND)
    set(FORCE_FRONTENDS_USE_PROTOBUF ON)
@ -216,4 +216,4 @@ if (ENABLE_PROFILING_RAW)
    add_definitions(-DENABLE_PROFILING_RAW=1)
 endif()

-print_enabled_features()
+ov_print_enabled_features()
--- a/cmake/templates/InferenceEngineConfig.cmake.in
+++ b/cmake/templates/InferenceEngineConfig.cmake.in
@ -25,6 +25,8 @@

@PACKAGE_INIT@

+message(WARNING "find_package(InferenceEngine) is deprecated and will be removed in 2024.0 release. Please, use find_package(OpenVINO)")
+
 if(NOT DEFINED CMAKE_FIND_PACKAGE_NAME)
    set(CMAKE_FIND_PACKAGE_NAME InferenceEngine)
    set(_ie_need_package_name_reset ON)
@ -77,7 +79,7 @@ endforeach()
 set(PACKAGE_PREFIX_DIR ${_ie_package_prefix_dir})
 unset(_ie_package_prefix_dir)

-set_and_check(InferenceEngine_INCLUDE_DIRS "@PACKAGE_IE_INCLUDE_DIR@")
+set_and_check(InferenceEngine_INCLUDE_DIRS "@PACKAGE_OV_INCLUDE_DIR@")

 check_required_components(${CMAKE_FIND_PACKAGE_NAME})

--- a/cmake/templates/InferenceEngineDeveloperPackageConfig.cmake.in
+++ b/cmake/templates/InferenceEngineDeveloperPackageConfig.cmake.in
@ -6,37 +6,39 @@

 include(CMakeFindDependencyMacro)

+message(WARNING "find_package(InferenceEngineDeveloperPackage) is deprecated and will be removed in 2024.0 release. Please, use find_package(OpenVINODeveloperPackage)")
+
 # TODO: remove after changing [private plugins]
 set_and_check(OpenVINO_SOURCE_DIR "@OpenVINO_SOURCE_DIR@") # NPU
 set_and_check(OpenVINO_MAIN_SOURCE_DIR "@OpenVINO_SOURCE_DIR@") # NPU

 # Variables to export in plugin's projects

-set(ie_options "@IE_OPTIONS@")
-list(APPEND ie_options CMAKE_CXX_COMPILER_LAUNCHER CMAKE_C_COMPILER_LAUNCHER
+set(ov_options "@OV_OPTIONS@")
+list(APPEND ov_options CMAKE_CXX_COMPILER_LAUNCHER CMAKE_C_COMPILER_LAUNCHER
                       CMAKE_CXX_LINKER_LAUNCHER CMAKE_C_LINKER_LAUNCHER
                       CMAKE_SKIP_RPATH CMAKE_INSTALL_PREFIX CPACK_GENERATOR)

 if(APPLE)
-    list(APPEND ie_options CMAKE_OSX_ARCHITECTURES CMAKE_OSX_DEPLOYMENT_TARGET)
+    list(APPEND ov_options CMAKE_OSX_ARCHITECTURES CMAKE_OSX_DEPLOYMENT_TARGET)
 endif()

-get_property(_IE_GENERATOR_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-if(_IE_GENERATOR_MULTI_CONFIG)
-    list(APPEND ie_options CMAKE_CONFIGURATION_TYPES)
+get_property(_OV_GENERATOR_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+if(_OV_GENERATOR_MULTI_CONFIG)
+    list(APPEND ov_options CMAKE_CONFIGURATION_TYPES)
    if(CMAKE_GENERATOR MATCHES "^Ninja Multi-Config$")
-        list(APPEND ie_options CMAKE_DEFAULT_BUILD_TYPE)
+        list(APPEND ov_options CMAKE_DEFAULT_BUILD_TYPE)
    endif()
 else()
-    list(APPEND ie_options CMAKE_BUILD_TYPE)
+    list(APPEND ov_options CMAKE_BUILD_TYPE)
 endif()
-unset(_IE_GENERATOR_MULTI_CONFIG)
+unset(_OV_GENERATOR_MULTI_CONFIG)

 file(TO_CMAKE_PATH "${CMAKE_CURRENT_LIST_DIR}" cache_path)

 message(STATUS "The following CMake options are exported from Inference Engine Developer package")
 message(" ")
-foreach(option IN LISTS ie_options)
+foreach(option IN LISTS ov_options)
    if(NOT DEFINED "${option}")
        load_cache("${cache_path}" READ_WITH_PREFIX "" ${option})
    endif()
@ -56,7 +58,7 @@ set(CMAKE_COMPILE_WARNING_AS_ERROR OFF)
 # Content
 #

-find_dependency(IEDevScripts
+find_dependency(OpenVINODeveloperScripts
                PATHS "${OpenVINO_SOURCE_DIR}/cmake/developer_package"
                NO_CMAKE_FIND_ROOT_PATH
                NO_DEFAULT_PATH)
@ -160,13 +162,13 @@ if(ENABLE_SYSTEM_PUGIXML)
    endif()
 endif()

-set(_IE_nlohmann_json_FOUND "@nlohmann_json_FOUND@")
-if(_IE_nlohmann_json_FOUND)
+set(_ov_nlohmann_json_FOUND "@nlohmann_json_FOUND@")
+if(_ov_nlohmann_json_FOUND)
    find_dependency(nlohmann_json)
    set_target_properties(nlohmann_json::nlohmann_json PROPERTIES IMPORTED_GLOBAL ON)
    add_library(IE::nlohmann_json ALIAS nlohmann_json::nlohmann_json)
 endif()
-unset(_IE_nlohmann_json_FOUND)
+unset(_ov_nlohmann_json_FOUND)

 # inherit OpenCV from main IE project if enabled
 if("@OpenCV_FOUND@")
--- a/cmake/templates/OpenVINOConfig.cmake.in
+++ b/cmake/templates/OpenVINOConfig.cmake.in
@ -176,7 +176,7 @@ macro(_ov_find_tbb)

            set(enable_system_tbb "@ENABLE_SYSTEM_TBB@")
            if(NOT enable_system_tbb)
-                set_and_check(_tbb_dir "@PACKAGE_IE_TBB_DIR@")
+                set_and_check(_tbb_dir "@PACKAGE_OV_TBB_DIR@")

                # see https://stackoverflow.com/questions/28070810/cmake-generate-error-on-windows-as-it-uses-as-escape-seq
                if(DEFINED ENV{TBBROOT})
@ -218,7 +218,7 @@ macro(_ov_find_tbb)

        set(install_tbbbind "@install_tbbbind@")
        if(install_tbbbind)
-            set_and_check(_tbb_bind_dir "@PACKAGE_IE_TBBBIND_DIR@")
+            set_and_check(_tbb_bind_dir "@PACKAGE_OV_TBBBIND_DIR@")
            _ov_find_dependency(TBBBIND_2_5
                                PATHS ${_tbb_bind_dir}
                                NO_CMAKE_FIND_ROOT_PATH
--- a/cmake/templates/OpenVINODeveloperPackageConfig.cmake.in
+++ b/cmake/templates/OpenVINODeveloperPackageConfig.cmake.in
@ -10,7 +10,7 @@ set_and_check(OpenVINO_SOURCE_DIR "@OpenVINO_SOURCE_DIR@")

 # Variables to export in plugin's projects

-set(ov_options "@IE_OPTIONS@")
+set(ov_options "@OV_OPTIONS@")
 list(APPEND ov_options CMAKE_CXX_COMPILER_LAUNCHER CMAKE_C_COMPILER_LAUNCHER
                       CMAKE_CXX_LINKER_LAUNCHER CMAKE_C_LINKER_LAUNCHER
                       CMAKE_SKIP_RPATH CMAKE_INSTALL_PREFIX CPACK_GENERATOR)
@ -20,7 +20,7 @@ if(APPLE)
 endif()

 get_property(_OV_GENERATOR_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-if(_IE_GENERATOR_MULTI_CONFIG)
+if(_OV_GENERATOR_MULTI_CONFIG)
    list(APPEND ov_options CMAKE_CONFIGURATION_TYPES)
    if(CMAKE_GENERATOR MATCHES "^Ninja Multi-Config$")
        list(APPEND ov_options CMAKE_DEFAULT_BUILD_TYPE)
@ -61,7 +61,7 @@ set(CMAKE_COMPILE_WARNING_AS_ERROR OFF)
 # Content
 #

-find_dependency(IEDevScripts
+find_dependency(OpenVINODeveloperScripts
                PATHS "${OpenVINO_SOURCE_DIR}/cmake/developer_package"
                NO_CMAKE_FIND_ROOT_PATH
                NO_DEFAULT_PATH)
--- a/cmake/templates/ngraphConfig.cmake.in
+++ b/cmake/templates/ngraphConfig.cmake.in
@ -42,6 +42,8 @@

 include(CMakeFindDependencyMacro)

+message(WARNING "find_package(ngraph) is deprecated and will be removed in 2024.0 release. Please, use find_package(OpenVINO)")
+
 find_dependency(OpenVINO
                PATHS "${CMAKE_CURRENT_LIST_DIR}"
                      "${CMAKE_CURRENT_LIST_DIR}/../openvino${ngraph_VERSION}"
--- a/samples/c/common/opencv_c_wrapper/CMakeLists.txt
+++ b/samples/c/common/opencv_c_wrapper/CMakeLists.txt
@ -28,6 +28,6 @@ target_include_directories(${TARGET_NAME} PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/in

 set_target_properties(${TARGET_NAME} PROPERTIES FOLDER c_samples)

-if(COMMAND ov_add_clang_format_target AND NOT IE_SAMPLE_EXCLUDE_CLANG_FORMAT)
+if(COMMAND ov_add_clang_format_target)
    ov_add_clang_format_target(${TARGET_NAME}_clang FOR_TARGETS ${TARGET_NAME})
 endif()
--- a/samples/c/hello_classification/CMakeLists.txt
+++ b/samples/c/hello_classification/CMakeLists.txt
@ -2,6 +2,6 @@
 # SPDX-License-Identifier: Apache-2.0
 #

-ie_add_sample(NAME hello_classification_c
+ov_add_sample(NAME hello_classification_c
              SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/main.c"
              DEPENDENCIES opencv_c_wrapper)
--- a/samples/c/hello_nv12_input_classification/CMakeLists.txt
+++ b/samples/c/hello_nv12_input_classification/CMakeLists.txt
@ -2,5 +2,5 @@
 # SPDX-License-Identifier: Apache-2.0
 #

-ie_add_sample(NAME hello_nv12_input_classification_c
+ov_add_sample(NAME hello_nv12_input_classification_c
              SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/main.c")
--- a/samples/cpp/CMakeLists.txt
+++ b/samples/cpp/CMakeLists.txt
@ -49,18 +49,18 @@ endif()

 if(OpenVINO_SOURCE_DIR)
    # in case if samples are built from IE repo
-    set(IE_MAIN_SAMPLES_DIR "${OpenVINO_SOURCE_DIR}")
+    set(OV_MAIN_SAMPLES_DIR "${OpenVINO_SOURCE_DIR}")
    set(OpenVINO_DIR "${CMAKE_BINARY_DIR}")
 else()
    # in case if samples are built out of IE repo
-    set(IE_MAIN_SAMPLES_DIR ${CMAKE_CURRENT_BINARY_DIR})
+    set(OV_MAIN_SAMPLES_DIR ${CMAKE_CURRENT_BINARY_DIR})
 endif()

-set (CMAKE_LIBRARY_OUTPUT_DIRECTORY ${IE_MAIN_SAMPLES_DIR}/${BIN_FOLDER})
-set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${IE_MAIN_SAMPLES_DIR}/${BIN_FOLDER})
-set (CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY ${IE_MAIN_SAMPLES_DIR}/${BIN_FOLDER})
-set (CMAKE_PDB_OUTPUT_DIRECTORY ${IE_MAIN_SAMPLES_DIR}/${BIN_FOLDER})
-set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${IE_MAIN_SAMPLES_DIR}/${BIN_FOLDER})
+set (CMAKE_LIBRARY_OUTPUT_DIRECTORY ${OV_MAIN_SAMPLES_DIR}/${BIN_FOLDER})
+set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${OV_MAIN_SAMPLES_DIR}/${BIN_FOLDER})
+set (CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY ${OV_MAIN_SAMPLES_DIR}/${BIN_FOLDER})
+set (CMAKE_PDB_OUTPUT_DIRECTORY ${OV_MAIN_SAMPLES_DIR}/${BIN_FOLDER})
+set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${OV_MAIN_SAMPLES_DIR}/${BIN_FOLDER})

 if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_SCL_SECURE_NO_WARNINGS -D_CRT_SECURE_NO_WARNINGS")
@ -155,7 +155,7 @@ if (DEFINED OpenVINO_SOURCE_DIR AND NOT ENABLE_SAMPLES)
    return()
 endif()

-function(add_samples_to_build)
+function(ov_add_samples_to_build)
    # check each passed sample subdirectory
    foreach (dir ${ARGN})
        if (IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${dir})
@ -175,37 +175,37 @@ function(add_samples_to_build)
            endif()
        endif()
    endforeach()
-endfunction(add_samples_to_build)
+endfunction(ov_add_samples_to_build)

 include(CMakeParseArguments)

 #
-# ie_add_sample(NAME <target name>
+# ov_add_sample(NAME <target name>
 #               SOURCES <source files>
 #               [HEADERS <header files>]
 #               [INCLUDE_DIRECTORIES <include dir>]
 #               [DEPENDENCIES <dependencies>]
 #               [EXCLUDE_CLANG_FORMAT]
 #
-macro(ie_add_sample)
+macro(ov_add_sample)
    set(options EXCLUDE_CLANG_FORMAT)
    set(oneValueArgs NAME)
    set(multiValueArgs SOURCES HEADERS DEPENDENCIES INCLUDE_DIRECTORIES)
-    cmake_parse_arguments(IE_SAMPLE "${options}" "${oneValueArgs}"
+    cmake_parse_arguments(SAMPLE "${options}" "${oneValueArgs}"
                          "${multiValueArgs}" ${ARGN} )

    # Create named folders for the sources within the .vcproj
    # Empty name lists them directly under the .vcproj
-    source_group("src" FILES ${IE_SAMPLE_SOURCES})
-    if(IE_SAMPLE_HEADERS)
-        source_group("include" FILES ${IE_SAMPLE_HEADERS})
+    source_group("src" FILES ${SAMPLE_SOURCES})
+    if(SAMPLE_HEADERS)
+        source_group("include" FILES ${SAMPLE_HEADERS})
    endif()

    # Create executable file from sources
-    add_executable(${IE_SAMPLE_NAME} ${IE_SAMPLE_SOURCES} ${IE_SAMPLE_HEADERS})
+    add_executable(${SAMPLE_NAME} ${SAMPLE_SOURCES} ${SAMPLE_HEADERS})

    set(folder_name cpp_samples)
-    if(IE_SAMPLE_NAME MATCHES ".*_c$")
+    if(SAMPLE_NAME MATCHES ".*_c$")
        set(c_sample ON)
        set(folder_name c_samples)
    endif()
@ -222,34 +222,46 @@ macro(ie_add_sample)
        set(ov_link_libraries openvino::runtime)
    endif()

-    set_target_properties(${IE_SAMPLE_NAME} PROPERTIES FOLDER ${folder_name}
-                                                       COMPILE_PDB_NAME ${IE_SAMPLE_NAME})
+    set_target_properties(${SAMPLE_NAME} PROPERTIES FOLDER ${folder_name}
+                                                       COMPILE_PDB_NAME ${SAMPLE_NAME})

-    if(IE_SAMPLE_INCLUDE_DIRECTORIES)
-        target_include_directories(${IE_SAMPLE_NAME} PRIVATE ${IE_SAMPLE_INCLUDE_DIRECTORIES})
+    if(SAMPLE_INCLUDE_DIRECTORIES)
+        target_include_directories(${SAMPLE_NAME} PRIVATE ${SAMPLE_INCLUDE_DIRECTORIES})
    endif()
-    target_include_directories(${IE_SAMPLE_NAME} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../common")
+    target_include_directories(${SAMPLE_NAME} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../common")

-    target_link_libraries(${IE_SAMPLE_NAME} PRIVATE ${ov_link_libraries} Threads::Threads ${IE_SAMPLE_DEPENDENCIES})
+    target_link_libraries(${SAMPLE_NAME} PRIVATE ${ov_link_libraries} Threads::Threads ${SAMPLE_DEPENDENCIES})

-    install(TARGETS ${IE_SAMPLE_NAME}
+    install(TARGETS ${SAMPLE_NAME}
            RUNTIME DESTINATION samples_bin/
            COMPONENT samples_bin
            EXCLUDE_FROM_ALL)

    # create global target with all samples / demo apps
-    if(NOT TARGET ie_samples)
-        add_custom_target(ie_samples ALL)
+    if(NOT TARGET ov_samples)
+        add_custom_target(ov_samples ALL)
    endif()
-    add_dependencies(ie_samples ${IE_SAMPLE_NAME})
+    add_dependencies(ov_samples ${SAMPLE_NAME})

-    if(COMMAND ov_add_clang_format_target AND NOT IE_SAMPLE_EXCLUDE_CLANG_FORMAT)
-        ov_add_clang_format_target(${IE_SAMPLE_NAME}_clang FOR_SOURCES ${IE_SAMPLE_SOURCES} ${IE_SAMPLE_HEADERS})
+    if(COMMAND ov_add_clang_format_target AND NOT SAMPLE_EXCLUDE_CLANG_FORMAT)
+        ov_add_clang_format_target(${SAMPLE_NAME}_clang FOR_SOURCES ${SAMPLE_SOURCES} ${SAMPLE_HEADERS})
    endif()
    if(COMMAND ov_ncc_naming_style AND NOT c_sample)
-        ov_ncc_naming_style(FOR_TARGET "${IE_SAMPLE_NAME}"
+        ov_ncc_naming_style(FOR_TARGET "${SAMPLE_NAME}"
                            SOURCE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}")
    endif()
+
+    unset(options)
+    unset(oneValueArgs)
+    unset(multiValueArgs)
+    unset(c_sample)
+    unset(folder_name)
+    unset(ov_link_libraries)
+    unset(SAMPLE_NAME)
+    unset(SAMPLE_HEADERS)
+    unset(SAMPLE_DEPENDENCIES)
+    unset(SAMPLE_EXCLUDE_CLANG_FORMAT)
+    unset(SAMPLE_INCLUDE_DIRECTORIES)
 endmacro()

 # collect all samples subdirectories
@ -261,4 +273,4 @@ if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/thirdparty")
 endif()
 list(REMOVE_ITEM samples_dirs common)

-add_samples_to_build(${samples_dirs})
+ov_add_samples_to_build(${samples_dirs})
--- a/samples/cpp/benchmark/sync_benchmark/CMakeLists.txt
+++ b/samples/cpp/benchmark/sync_benchmark/CMakeLists.txt
@ -2,6 +2,6 @@
 # SPDX-License-Identifier: Apache-2.0
 #

-ie_add_sample(NAME sync_benchmark
+ov_add_sample(NAME sync_benchmark
              SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/main.cpp"
              DEPENDENCIES ie_samples_utils)
--- a/samples/cpp/benchmark/throughput_benchmark/CMakeLists.txt
+++ b/samples/cpp/benchmark/throughput_benchmark/CMakeLists.txt
@ -2,6 +2,6 @@
 # SPDX-License-Identifier: Apache-2.0
 #

-ie_add_sample(NAME throughput_benchmark
+ov_add_sample(NAME throughput_benchmark
              SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/main.cpp"
              DEPENDENCIES ie_samples_utils)
--- a/samples/cpp/benchmark_app/CMakeLists.txt
+++ b/samples/cpp/benchmark_app/CMakeLists.txt
@ -7,7 +7,7 @@ set(TARGET_NAME "benchmark_app")
 file (GLOB SRC ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
 file (GLOB HDR ${CMAKE_CURRENT_SOURCE_DIR}/*.hpp)

-ie_add_sample(NAME ${TARGET_NAME}
+ov_add_sample(NAME ${TARGET_NAME}
              SOURCES ${SRC}
              HEADERS ${HDR}
              DEPENDENCIES ${GFLAGS_TARGET} format_reader ie_samples_utils)
--- a/samples/cpp/classification_sample_async/CMakeLists.txt
+++ b/samples/cpp/classification_sample_async/CMakeLists.txt
@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 #

-ie_add_sample(NAME classification_sample_async
+ov_add_sample(NAME classification_sample_async
              SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/main.cpp"
              HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/classification_sample_async.h"
              DEPENDENCIES ${GFLAGS_TARGET} format_reader ie_samples_utils)
--- a/samples/cpp/hello_classification/CMakeLists.txt
+++ b/samples/cpp/hello_classification/CMakeLists.txt
@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 #

-ie_add_sample(NAME hello_classification
+ov_add_sample(NAME hello_classification
              SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/main.cpp"
              DEPENDENCIES format_reader ie_samples_utils)

--- a/samples/cpp/hello_nv12_input_classification/CMakeLists.txt
+++ b/samples/cpp/hello_nv12_input_classification/CMakeLists.txt
@ -2,6 +2,6 @@
 # SPDX-License-Identifier: Apache-2.0
 #

-ie_add_sample(NAME hello_nv12_input_classification
+ov_add_sample(NAME hello_nv12_input_classification
              SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/main.cpp"
              DEPENDENCIES format_reader ie_samples_utils)
--- a/samples/cpp/hello_query_device/CMakeLists.txt
+++ b/samples/cpp/hello_query_device/CMakeLists.txt
@ -2,6 +2,6 @@
 # SPDX-License-Identifier: Apache-2.0
 #

-ie_add_sample(NAME hello_query_device
+ov_add_sample(NAME hello_query_device
              SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/main.cpp"
              DEPENDENCIES ie_samples_utils)
--- a/samples/cpp/hello_reshape_ssd/CMakeLists.txt
+++ b/samples/cpp/hello_reshape_ssd/CMakeLists.txt
@ -2,6 +2,6 @@
 # SPDX-License-Identifier: Apache-2.0
 #

-ie_add_sample(NAME hello_reshape_ssd
+ov_add_sample(NAME hello_reshape_ssd
              SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/main.cpp"
              DEPENDENCIES format_reader ie_samples_utils)
--- a/samples/cpp/model_creation_sample/CMakeLists.txt
+++ b/samples/cpp/model_creation_sample/CMakeLists.txt
@ -4,7 +4,7 @@

 set(TARGET_NAME "model_creation_sample")

-ie_add_sample(NAME model_creation_sample
+ov_add_sample(NAME model_creation_sample
              SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/main.cpp"
              HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/model_creation_sample.hpp"
              DEPENDENCIES format_reader ie_samples_utils)
--- a/samples/cpp/speech_sample/CMakeLists.txt
+++ b/samples/cpp/speech_sample/CMakeLists.txt
@ -46,7 +46,7 @@ endif()

 # add sample

-ie_add_sample(NAME speech_sample
+ov_add_sample(NAME speech_sample
              SOURCES ${SRC}
              HEADERS ${HDR}
              DEPENDENCIES ${GFLAGS_TARGET} cnpy ie_samples_utils)
--- a/scripts/CMakeLists.txt
+++ b/scripts/CMakeLists.txt
@ -15,7 +15,7 @@ set(shellcheck_skip_list
    "${OpenVINO_SOURCE_DIR}/src/bindings/python/thirdparty/pybind11"
    "${TEMP}")

-ie_shellcheck_process(DIRECTORY "${OpenVINO_SOURCE_DIR}"
+ov_shellcheck_process(DIRECTORY "${OpenVINO_SOURCE_DIR}"
                      SKIP ${shellcheck_skip_list})

 #
--- a/src/bindings/c/tests/test_model_repo.cpp
+++ b/src/bindings/c/tests/test_model_repo.cpp
@ -38,7 +38,7 @@ std::string generate_test_xml_file() {
    plugin_xml_file << ov::util::FileTraits<char>::file_separator;
    plugin_xml_file << ov::util::FileTraits<char>::library_prefix();
    plugin_xml_file << "mock_engine";
-    plugin_xml_file << IE_BUILD_POSTFIX;
+    plugin_xml_file << OV_BUILD_POSTFIX;
    plugin_xml_file << ov::util::FileTraits<char>::dot_symbol;
    plugin_xml_file << ov::util::FileTraits<char>::library_ext();
    plugin_xml_file << "\" name=\"CUSTOM\">\n";
--- a/src/bindings/python/CMakeLists.txt
+++ b/src/bindings/python/CMakeLists.txt
@ -152,7 +152,7 @@ endfunction()

 ov_check_init_files_alignment()

-ie_option(ENABLE_PYTHON "Enables OpenVINO Python API build" ${ENABLE_PYTHON_DEFAULT})
+ov_option(ENABLE_PYTHON "Enables OpenVINO Python API build" ${ENABLE_PYTHON_DEFAULT})

 #
 # Check for wheel package
@ -196,7 +196,7 @@ endif()

 # this option should not be a part of OpenVINODeveloperPackage
 # since wheels can be built only together with main OV build
-ie_dependent_option(ENABLE_WHEEL "Build wheel packages for PyPI" ${ENABLE_WHEEL_DEFAULT} "ENABLE_PYTHON" OFF)
+ov_dependent_option(ENABLE_WHEEL "Build wheel packages for PyPI" ${ENABLE_WHEEL_DEFAULT} "ENABLE_PYTHON" OFF)

 if(NOT ENABLE_PYTHON)
    if(CMAKE_SOURCE_DIR STREQUAL OpenVINOPython_SOURCE_DIR)
@ -400,5 +400,5 @@ if(OpenVINODeveloperPackage_FOUND)
    # provides a callback function to describe each component in repo
    include("${OpenVINO_SOURCE_DIR}/cmake/packaging/packaging.cmake")

-    ie_cpack(${IE_CPACK_COMPONENTS_ALL})
+    ov_cpack(${OV_CPACK_COMPONENTS_ALL})
 endif()
--- a/src/bindings/python/src/compatibility/openvino/inference_engine/CMakeLists.txt
+++ b/src/bindings/python/src/compatibility/openvino/inference_engine/CMakeLists.txt
@ -64,7 +64,7 @@ endif()
 function(python_ov_disable_deprecated_warnings)
    ov_disable_deprecated_warnings()
    set(pyx_file "${CMAKE_CURRENT_BINARY_DIR}/ie_api.cxx" "${CMAKE_CURRENT_BINARY_DIR}/constants.cxx")
-    set_source_files_properties(${pyx_file} PROPERTIES COMPILE_OPTIONS ${ie_c_cxx_deprecated})
+    set_source_files_properties(${pyx_file} PROPERTIES COMPILE_OPTIONS ${ov_c_cxx_deprecated})
 endfunction()

 python_ov_disable_deprecated_warnings()
--- a/src/cmake/install_tbb.cmake
+++ b/src/cmake/install_tbb.cmake
@ -67,13 +67,13 @@ unset(_ov_dynamic_tbbbind_2_5_found)

 # define variables for OpenVINOConfig.cmake
 if(THREADING MATCHES "^(TBB|TBB_AUTO)$")
-    set(IE_TBB_DIR "${TBB_DIR}")
-    list(APPEND PATH_VARS "IE_TBB_DIR")
+    set(OV_TBB_DIR "${TBB_DIR}")
+    list(APPEND PATH_VARS "OV_TBB_DIR")
 endif()

 if(install_tbbbind)
-    set(IE_TBBBIND_DIR "${TBBBIND_2_5_DIR}")
-    list(APPEND PATH_VARS "IE_TBBBIND_DIR")
+    set(OV_TBBBIND_DIR "${TBBBIND_2_5_DIR}")
+    list(APPEND PATH_VARS "OV_TBBBIND_DIR")
 endif()

 # install only downloaded | custom TBB, system one is not installed
@ -150,14 +150,14 @@ if(THREADING MATCHES "^(TBB|TBB_AUTO)$" AND
        endif()

        if(TBB_DIR MATCHES "^${TBBROOT}.*")
-            file(RELATIVE_PATH IE_TBB_DIR_INSTALL "${TBBROOT}" "${TBB_DIR}")
-            set(IE_TBB_DIR_INSTALL "${IE_TBBROOT_INSTALL}/${IE_TBB_DIR_INSTALL}")
+            file(RELATIVE_PATH OV_TBB_DIR_INSTALL "${TBBROOT}" "${TBB_DIR}")
+            set(OV_TBB_DIR_INSTALL "${IE_TBBROOT_INSTALL}/${OV_TBB_DIR_INSTALL}")
        else()
            # TBB_DIR is not a subdirectory of TBBROOT
            # example: old TBB 2017 with no cmake support at all
            # - TBBROOT point to actual root of TBB
            # - TBB_DIR points to cmake/developer_package/tbb/<lnx|mac|win>
-            set(IE_TBB_DIR_INSTALL "${TBB_DIR}")
+            set(OV_TBB_DIR_INSTALL "${TBB_DIR}")
        endif()

        # try to select proper library directory
@ -185,21 +185,21 @@ if(THREADING MATCHES "^(TBB|TBB_AUTO)$" AND

        set(pkg_config_tbb_lib_dir "${IE_TBBROOT_INSTALL}/${tbb_libs_dir}")
    elseif(tbb_downloaded)
-        set(IE_TBB_DIR_INSTALL "runtime/3rdparty/tbb")
+        set(OV_TBB_DIR_INSTALL "runtime/3rdparty/tbb")

        if(WIN32)
            install(DIRECTORY "${TBBROOT}/bin"
-                    DESTINATION "${IE_TBB_DIR_INSTALL}"
+                    DESTINATION "${OV_TBB_DIR_INSTALL}"
                    COMPONENT tbb)
        else()
            install(DIRECTORY "${TBBROOT}/lib"
-                    DESTINATION "${IE_TBB_DIR_INSTALL}"
+                    DESTINATION "${OV_TBB_DIR_INSTALL}"
                    COMPONENT tbb
                    PATTERN "cmake" EXCLUDE)
        endif()

        install(FILES "${TBBROOT}/LICENSE"
-                DESTINATION "${IE_TBB_DIR_INSTALL}"
+                DESTINATION "${OV_TBB_DIR_INSTALL}"
                COMPONENT tbb)

        # install development files
@ -212,29 +212,29 @@ if(THREADING MATCHES "^(TBB|TBB_AUTO)$" AND
        if(EXISTS "${TBBROOT}/lib/cmake")
            # oneTBB case
            install(DIRECTORY "${TBBROOT}/lib/cmake"
-                    DESTINATION "${IE_TBB_DIR_INSTALL}/lib"
+                    DESTINATION "${OV_TBB_DIR_INSTALL}/lib"
                    COMPONENT tbb_dev)
        else()
            # tbb2020 case
            install(FILES "${TBBROOT}/cmake/TBBConfig.cmake"
                          "${TBBROOT}/cmake/TBBConfigVersion.cmake"
-                    DESTINATION "${IE_TBB_DIR_INSTALL}/cmake"
+                    DESTINATION "${OV_TBB_DIR_INSTALL}/cmake"
                    COMPONENT tbb_dev)
        endif()

        install(DIRECTORY "${TBBROOT}/include"
-                DESTINATION "${IE_TBB_DIR_INSTALL}"
+                DESTINATION "${OV_TBB_DIR_INSTALL}"
                COMPONENT tbb_dev)

        if(WIN32)
            # .lib files are needed only for Windows
            install(DIRECTORY "${TBBROOT}/lib"
-                    DESTINATION "${IE_TBB_DIR_INSTALL}"
+                    DESTINATION "${OV_TBB_DIR_INSTALL}"
                    COMPONENT tbb_dev
                    PATTERN "cmake" EXCLUDE)
        endif()

-        set(pkg_config_tbb_lib_dir "${IE_TBB_DIR_INSTALL}/lib")
+        set(pkg_config_tbb_lib_dir "${OV_TBB_DIR_INSTALL}/lib")
    else()
        message(WARNING "TBB of unknown origin. TBB files are not installed")
    endif()
@ -245,16 +245,16 @@ endif()

 # install tbbbind for static OpenVINO case
 if(install_tbbbind)
-    set(IE_TBBBIND_DIR_INSTALL "runtime/3rdparty/tbb_bind_2_5")
+    set(OV_TBBBIND_DIR_INSTALL "runtime/3rdparty/tbb_bind_2_5")

    install(DIRECTORY "${TBBBIND_2_5_ROOT}/lib"
-            DESTINATION "${IE_TBBBIND_DIR_INSTALL}"
+            DESTINATION "${OV_TBBBIND_DIR_INSTALL}"
            COMPONENT tbb)
    install(FILES "${TBBBIND_2_5_ROOT}/LICENSE"
-            DESTINATION "${IE_TBBBIND_DIR_INSTALL}"
+            DESTINATION "${OV_TBBBIND_DIR_INSTALL}"
            COMPONENT tbb)

    install(FILES "${TBBBIND_2_5_ROOT}/cmake/TBBBIND_2_5Config.cmake"
-            DESTINATION "${IE_TBBBIND_DIR_INSTALL}/cmake"
+            DESTINATION "${OV_TBBBIND_DIR_INSTALL}/cmake"
            COMPONENT tbb_dev)
 endif()
--- a/src/cmake/openvino.cmake
+++ b/src/cmake/openvino.cmake
@ -157,7 +157,7 @@ install(EXPORT OpenVINOTargets

 # build tree

-list(APPEND PATH_VARS "IE_INCLUDE_DIR")
+list(APPEND PATH_VARS "OV_INCLUDE_DIR") # TODO: remove obsolete variable for API 1.0 before 2024.0
 if(ENABLE_INTEL_GNA)
    list(APPEND PATH_VARS "GNA_PATH")
 endif()
@ -170,8 +170,8 @@ if(ENABLE_ONEDNN_FOR_GPU)
 endif()

 set(PUBLIC_HEADERS_DIR "${OpenVINO_SOURCE_DIR}/src/inference/include")
-set(IE_INCLUDE_DIR "${PUBLIC_HEADERS_DIR}/ie")
-set(IE_TBB_DIR "${TBB_DIR}")
+set(OV_INCLUDE_DIR "${PUBLIC_HEADERS_DIR}/ie")
+set(OV_TBB_DIR "${TBB_DIR}")

 configure_package_config_file("${OpenVINO_SOURCE_DIR}/cmake/templates/InferenceEngineConfig.cmake.in"
                              "${CMAKE_BINARY_DIR}/InferenceEngineConfig.cmake"
@ -190,9 +190,9 @@ list(APPEND INSTALL_PATH_VARS "OPENVINO_LIB_DIR")
 # will be done by inside OpenVINOConfig.cmak / ACLConfig.cmake
 string(REPLACE "$<CONFIG>" "" OPENVINO_LIB_DIR "${OV_CPACK_LIBRARYDIR}")

-set(IE_INCLUDE_DIR "${OV_CPACK_INCLUDEDIR}/ie")
-set(IE_TBB_DIR "${IE_TBB_DIR_INSTALL}")
-set(IE_TBBBIND_DIR "${IE_TBBBIND_DIR_INSTALL}")
+set(OV_INCLUDE_DIR "${OV_CPACK_INCLUDEDIR}/ie")
+set(OV_TBB_DIR "${OV_TBB_DIR_INSTALL}")
+set(OV_TBBBIND_DIR "${OV_TBBBIND_DIR_INSTALL}")
 set(GNA_PATH "${OV_CPACK_RUNTIMEDIR}")
 if(WIN32)
    set(GNA_PATH "${OV_CPACK_LIBRARYDIR}/../Release")
--- a/src/cmake/ov_parallel.cmake
+++ b/src/cmake/ov_parallel.cmake
@ -170,7 +170,7 @@ macro(ov_find_package_tbb)
                # fallback variant for TBB 2018 and older where TBB have not had cmake interface
                if(DEFINED TBBROOT OR DEFINED ENV{TBBROOT})
                    # note: if TBB older than 2017.0 is passed, cmake will skip it and THREADING=SEQ will be used
-                    set(_tbb_paths PATHS "${IEDevScripts_DIR}/tbb")
+                    set(_tbb_paths PATHS "${OpenVINODeveloperScripts_DIR}/tbb")
                endif()

                # try to find one more time
@ -279,7 +279,7 @@ function(ov_set_threading_interface_for TARGET_NAME)
        message(WARNING "Unknown target type")
    endif()

-    function(ie_target_link_libraries TARGET_NAME LINK_TYPE)
+    function(_ov_target_link_libraries TARGET_NAME LINK_TYPE)
        target_link_libraries(${TARGET_NAME} ${LINK_TYPE} ${ARGN})

        # include directories as SYSTEM
@ -314,7 +314,7 @@ function(ov_set_threading_interface_for TARGET_NAME)
        if (TBB_FOUND)
            set(IE_THREAD_DEFINE "IE_THREAD_TBB")
            set(OV_THREAD_DEFINE "OV_THREAD_TBB")
-            ie_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} TBB::tbb)
+            _ov_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} TBB::tbb)
            target_compile_definitions(${TARGET_NAME} ${COMPILE_DEF_TYPE} TBB_PREVIEW_WAITING_FOR_WORKERS=1)
        else ()
            set(THREADING "SEQ" PARENT_SCOPE)
@ -365,7 +365,7 @@ function(ov_set_threading_interface_for TARGET_NAME)
            if (WIN32)
                target_compile_options(${TARGET_NAME} ${LINK_TYPE} ${OpenMP_CXX_FLAGS} /openmp)
                target_compile_options(${TARGET_NAME} ${LINK_TYPE} ${OpenMP_CXX_FLAGS} /Qopenmp)
-                ie_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} "-nodefaultlib:vcomp")
+                _ov_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} "-nodefaultlib:vcomp")
            else()
                target_compile_options(${TARGET_NAME} ${LINK_TYPE} ${OpenMP_CXX_FLAGS} -fopenmp)
            endif ()
@ -373,18 +373,18 @@ function(ov_set_threading_interface_for TARGET_NAME)
            # Debug binaries are optional.
            if (OMP_LIBRARIES_DEBUG AND NOT LINUX)
                if (WIN32)
-                    ie_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} "$<$<CONFIG:DEBUG>:${OMP_LIBRARIES_DEBUG}>;$<$<NOT:$<CONFIG:DEBUG>>:${OMP_LIBRARIES_RELEASE}>")
+                    _ov_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} "$<$<CONFIG:DEBUG>:${OMP_LIBRARIES_DEBUG}>;$<$<NOT:$<CONFIG:DEBUG>>:${OMP_LIBRARIES_RELEASE}>")
                else()
                    # TODO: handle multi-config generators case
                    if (CMAKE_BUILD_TYPE STREQUAL "Debug")
-                        ie_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} ${OMP_LIBRARIES_DEBUG})
+                        _ov_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} ${OMP_LIBRARIES_DEBUG})
                    else()
-                        ie_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} ${OMP_LIBRARIES_RELEASE})
+                        _ov_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} ${OMP_LIBRARIES_RELEASE})
                    endif ()
                endif ()
            else ()
                # Link Release library to all configurations.
-                ie_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} ${OMP_LIBRARIES_RELEASE})
+                _ov_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} ${OMP_LIBRARIES_RELEASE})
            endif ()
        endif ()
    endif ()
@ -394,11 +394,13 @@ function(ov_set_threading_interface_for TARGET_NAME)

    if (NOT THREADING STREQUAL "SEQ")
        find_package(Threads REQUIRED)
-        ie_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} Threads::Threads)
+        _ov_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} Threads::Threads)
    endif()
 endfunction(ov_set_threading_interface_for)

+# deprecated
+
 function(set_ie_threading_interface_for TARGET_NAME)
-    message(WARNING "This function is deprecated. Please use ov_set_threading_interface_for(TARGET_NAME) instead.")
+    message(WARNING "'set_ie_threading_interface_for' is deprecated. Please use 'ov_set_threading_interface_for' instead.")
    ov_set_threading_interface_for(${TARGET_NAME})
 endfunction(set_ie_threading_interface_for)
--- a/src/common/preprocessing/src/CMakeLists.txt
+++ b/src/common/preprocessing/src/CMakeLists.txt
@ -37,7 +37,7 @@ if(ENABLE_SSE42)
    list(APPEND LIBRARY_HEADERS ${SSE_HEADERS})
    list(APPEND LIBRARY_SRC ${SSE_SRC})

-    ie_sse42_optimization_flags(sse4_2_flags)
+    ov_sse42_optimization_flags(sse4_2_flags)
    set_source_files_properties(${SSE_SRC} PROPERTIES COMPILE_OPTIONS "${sse4_2_flags}")
    add_definitions(-DHAVE_SSE=1)
 endif()
@ -49,7 +49,7 @@ if(ENABLE_AVX2)
    list(APPEND LIBRARY_HEADERS ${AVX2_HEADERS})
    list(APPEND LIBRARY_SRC ${AVX2_SRC})

-    ie_avx2_optimization_flags(avx2_flags)
+    ov_avx2_optimization_flags(avx2_flags)
    set_source_files_properties(${AVX2_SRC} PROPERTIES COMPILE_OPTIONS "${avx2_flags}")
    add_definitions(-DHAVE_AVX2=1)
 endif()
@ -75,7 +75,7 @@ if(ENABLE_AVX512F AND NOT GNU_5_DEBUG_CASE)
 endif()

 if(ARM OR AARCH64)
-    ie_arm_neon_optimization_flags(neon_flags)
+    ov_arm_neon_optimization_flags(neon_flags)

    file(GLOB NEON_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/arm_neon/*.hpp)
    file(GLOB NEON_SRC ${CMAKE_CURRENT_SOURCE_DIR}/arm_neon/*.cpp)
--- a/src/common/preprocessing/src/ie_preprocess_data.hpp
+++ b/src/common/preprocessing/src/ie_preprocess_data.hpp
@ -84,7 +84,7 @@ public:
        // 2. in the same folder as libopenvino.so

        ov::util::FilePath ovLibraryPath = getInferenceEngineLibraryPath();
-        ov::util::FilePath libraryName = ov::util::to_file_path(std::string("openvino_gapi_preproc") + std::string(IE_BUILD_POSTFIX));
+        ov::util::FilePath libraryName = ov::util::to_file_path(std::string("openvino_gapi_preproc") + std::string(OV_BUILD_POSTFIX));
        libraryName = FileUtils::makePluginLibraryName({}, libraryName);

        std::ostringstream str;
--- a/src/core/tests/CMakeLists.txt
+++ b/src/core/tests/CMakeLists.txt
@ -57,10 +57,10 @@ target_include_directories(${TARGET_NAME} PRIVATE ${OV_CORE_SRC_DIR}/src
 target_compile_definitions(${TARGET_NAME}
    PRIVATE
        SHARED_LIB_PREFIX="${CMAKE_SHARED_LIBRARY_PREFIX}"
-        SHARED_LIB_SUFFIX="${IE_BUILD_POSTFIX}${CMAKE_SHARED_LIBRARY_SUFFIX}"
+        SHARED_LIB_SUFFIX="${OV_BUILD_POSTFIX}${CMAKE_SHARED_LIBRARY_SUFFIX}"
        FRONTEND_LIB_PREFIX="${CMAKE_SHARED_LIBRARY_PREFIX}${FRONTEND_NAME_PREFIX}"
        # Assume <lib>.so is an existed symlink to <lib><version>.so (or <lib>.so<version>
-        FRONTEND_LIB_SUFFIX="${FRONTEND_NAME_SUFFIX}${IE_BUILD_POSTFIX}${CMAKE_SHARED_LIBRARY_SUFFIX}"
+        FRONTEND_LIB_SUFFIX="${FRONTEND_NAME_SUFFIX}${OV_BUILD_POSTFIX}${CMAKE_SHARED_LIBRARY_SUFFIX}"
        )

 if(RISCV64)
--- a/src/core/tests/extension.cpp
+++ b/src/core/tests/extension.cpp
@ -15,7 +15,7 @@

 inline std::string get_extension_path() {
    return ov::util::make_plugin_library_name<char>(ov::test::utils::getExecutableDirectory(),
-                                                    std::string("openvino_template_extension") + IE_BUILD_POSTFIX);
+                                                    std::string("openvino_template_extension") + OV_BUILD_POSTFIX);
 }

 TEST(extension, load_extension) {
--- a/src/frontends/common/CMakeLists.txt
+++ b/src/frontends/common/CMakeLists.txt
@ -39,7 +39,7 @@ target_link_libraries(${TARGET_NAME}_obj PRIVATE openvino::util openvino::core::
 set_target_properties(${TARGET_NAME}_obj PROPERTIES
    INTERPROCEDURAL_OPTIMIZATION_RELEASE OFF)

-set(FRONTEND_LIB_SUFFIX "${FRONTEND_NAME_SUFFIX}${IE_BUILD_POSTFIX}")
+set(FRONTEND_LIB_SUFFIX "${FRONTEND_NAME_SUFFIX}${OV_BUILD_POSTFIX}")
 if(APPLE)
    set(FRONTEND_LIB_SUFFIX "${FRONTEND_LIB_SUFFIX}${OpenVINO_VERSION_SUFFIX}${CMAKE_SHARED_LIBRARY_SUFFIX}")
 else()
--- a/src/frontends/onnx/tests/CMakeLists.txt
+++ b/src/frontends/onnx/tests/CMakeLists.txt
@ -133,7 +133,7 @@ target_include_directories(ov_onnx_frontend_tests PRIVATE "${CMAKE_CURRENT_SOURC
 target_compile_definitions(ov_onnx_frontend_tests
    PRIVATE
        SHARED_LIB_PREFIX="${CMAKE_SHARED_LIBRARY_PREFIX}"
-        SHARED_LIB_SUFFIX="${IE_BUILD_POSTFIX}${CMAKE_SHARED_LIBRARY_SUFFIX}")
+        SHARED_LIB_SUFFIX="${OV_BUILD_POSTFIX}${CMAKE_SHARED_LIBRARY_SUFFIX}")

 set(ONNX_OPSET_VERSION 17 CACHE INTERNAL "Supported version of ONNX operator set")
 target_compile_definitions(ov_onnx_frontend_tests PRIVATE ONNX_OPSET_VERSION=${ONNX_OPSET_VERSION})
--- a/src/frontends/tests/frontend/shared/CMakeLists.txt
+++ b/src/frontends/tests/frontend/shared/CMakeLists.txt
@ -28,6 +28,6 @@ add_dependencies(${TARGET_NAME} test_builtin_extensions)
 target_compile_definitions(${TARGET_NAME}
    PRIVATE
        SHARED_LIB_PREFIX="${CMAKE_SHARED_LIBRARY_PREFIX}"
-        SHARED_LIB_SUFFIX="${IE_BUILD_POSTFIX}${CMAKE_SHARED_LIBRARY_SUFFIX}")
+        SHARED_LIB_SUFFIX="${OV_BUILD_POSTFIX}${CMAKE_SHARED_LIBRARY_SUFFIX}")

 ov_add_clang_format_target(${TARGET_NAME}_clang FOR_TARGETS ${TARGET_NAME})
--- a/src/frontends/tests/frontend/shared/src/conversion.cpp
+++ b/src/frontends/tests/frontend/shared/src/conversion.cpp
@ -30,7 +30,7 @@ void FrontEndConversionExtensionTest::initParamTest() {

 inline std::string get_lib_path(const std::string& lib_name) {
    return ov::util::make_plugin_library_name<char>(ov::test::utils::getExecutableDirectory(),
-                                                    lib_name + IE_BUILD_POSTFIX);
+                                                    lib_name + OV_BUILD_POSTFIX);
 }

 ///////////////////////////////////////////////////////////////////
--- a/src/frontends/tests/frontend/shared/src/library_extension.cpp
+++ b/src/frontends/tests/frontend/shared/src/library_extension.cpp
@ -31,7 +31,7 @@ void FrontendLibraryExtensionTest::initParamTest() {

 inline std::string get_lib_path(const std::string& lib_name) {
    return ov::util::make_plugin_library_name<char>(ov::test::utils::getExecutableDirectory(),
-                                                    lib_name + IE_BUILD_POSTFIX);
+                                                    lib_name + OV_BUILD_POSTFIX);
 }

 ///////////////////////////////////////////////////////////////////
--- a/src/inference/CMakeLists.txt
+++ b/src/inference/CMakeLists.txt
@ -20,8 +20,8 @@ file (GLOB LIBRARY_SRC
        ${CMAKE_CURRENT_SOURCE_DIR}/src/cpp_interfaces/interface/*.cpp
      )

-set(IE_STATIC_DEPENDENT_FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/file_utils.cpp)
-list(REMOVE_ITEM LIBRARY_SRC ${IE_STATIC_DEPENDENT_FILES})
+set(OV_STATIC_DEPENDENT_FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/file_utils.cpp)
+list(REMOVE_ITEM LIBRARY_SRC ${OV_STATIC_DEPENDENT_FILES})

 if(BUILD_SHARED_LIBS OR ENABLE_IR_V7_READER)
    # TODO: remove together with GNA plugin
@ -66,7 +66,7 @@ if(ENABLE_SSE42)
    list(APPEND LIBRARY_HEADERS ${SSE_HEADERS})
    list(APPEND LIBRARY_SRC ${SSE_SRC})

-    ie_sse42_optimization_flags(sse4_2_flags)
+    ov_sse42_optimization_flags(sse4_2_flags)
    set_source_files_properties(${SSE_SRC} PROPERTIES COMPILE_OPTIONS "${sse4_2_flags}")
    add_definitions(-DHAVE_SSE=1)

@ -118,7 +118,7 @@ ov_ncc_naming_style(FOR_TARGET ${TARGET_NAME}_plugin_api
 # Create object library

 add_library(${TARGET_NAME}_obj OBJECT
-            ${IE_STATIC_DEPENDENT_FILES}
+            ${OV_STATIC_DEPENDENT_FILES}
            ${LIBRARY_SRC}
            ${LIBRARY_HEADERS}
            ${PUBLIC_HEADERS})
@ -174,7 +174,7 @@ target_link_libraries(${TARGET_NAME} INTERFACE openvino::runtime)
 target_include_directories(${TARGET_NAME} INTERFACE $<BUILD_INTERFACE:${PUBLIC_HEADERS_DIR}>
                                                    $<BUILD_INTERFACE:${PUBLIC_HEADERS_DIR}/ie>)

-ov_add_clang_format_target(${TARGET_NAME}_clang FOR_SOURCES ${IE_STATIC_DEPENDENT_FILES} ${LIBRARY_SRC} ${LIBRARY_HEADERS} ${PUBLIC_HEADERS})
+ov_add_clang_format_target(${TARGET_NAME}_clang FOR_SOURCES ${OV_STATIC_DEPENDENT_FILES} ${LIBRARY_SRC} ${LIBRARY_HEADERS} ${PUBLIC_HEADERS})

 ov_ncc_naming_style(FOR_TARGET ${TARGET_NAME}_obj
                    SOURCE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/include/openvino"
--- a/src/inference/src/ie_network_reader.cpp
+++ b/src/inference/src/ie_network_reader.cpp
@ -113,7 +113,7 @@ void registerReaders() {
    // try to load IR reader v7 if library exists
    try {
        reader_irv7 =
-            std::make_shared<Reader>(std::string("inference_engine_ir_v7_reader") + std::string(IE_BUILD_POSTFIX));
+            std::make_shared<Reader>(std::string("inference_engine_ir_v7_reader") + std::string(OV_BUILD_POSTFIX));
    } catch (const std::runtime_error&) {
        // runtime error is thrown in case of library cannot be loaded
    }
--- a/src/inference/tests/functional/caching_test.cpp
+++ b/src/inference/tests/functional/caching_test.cpp
@ -161,7 +161,7 @@ public:
    static std::string get_mock_engine_path() {
        std::string mockEngineName("mock_engine");
        return ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                                  mockEngineName + IE_BUILD_POSTFIX);
+                                                  mockEngineName + OV_BUILD_POSTFIX);
    }

    void initParamTest() {
@ -232,7 +232,7 @@ public:
        ov::Core core;
        injectPlugin(mockPlugin.get());
        core.register_plugin(ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                                                std::string("mock_engine") + IE_BUILD_POSTFIX),
+                                                                std::string("mock_engine") + OV_BUILD_POSTFIX),
                             deviceName);
        func(core);
        core.unload_plugin(deviceName);
--- a/src/inference/tests/functional/core_threading.cpp
+++ b/src/inference/tests/functional/core_threading.cpp
@ -63,7 +63,7 @@ public:
        try {
            auto extension = std::make_shared<InferenceEngine::Extension>(
                ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                                   std::string("template_extension") + IE_BUILD_POSTFIX));
+                                                   std::string("template_extension") + OV_BUILD_POSTFIX));
            ie.AddExtension(extension);
        } catch (const InferenceEngine::Exception& ex) {
            ASSERT_STR_CONTAINS(ex.what(), "name: custom_opset. Opset");
@ -95,7 +95,7 @@ TEST_F(IECoreThreadingTests, RegisterPlugin) {
        [&]() {
            const std::string deviceName = std::to_string(index++);
            ie.RegisterPlugin(ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                                                 std::string("mock_engine") + IE_BUILD_POSTFIX),
+                                                                 std::string("mock_engine") + OV_BUILD_POSTFIX),
                              deviceName);
            ie.GetVersions(deviceName);
            ie.UnregisterPlugin(deviceName);
@ -118,7 +118,7 @@ TEST_F(IECoreThreadingTests, RegisterPlugins) {
        file << ov::util::FileTraits<char>::file_separator;
        file << ov::util::FileTraits<char>::library_prefix();
        file << "mock_engine";
-        file << IE_BUILD_POSTFIX;
+        file << OV_BUILD_POSTFIX;
        file << ov::util::FileTraits<char>::dot_symbol;
        file << ov::util::FileTraits<char>::library_ext();
        file << "\" name=\"";
--- a/src/inference/tests/functional/get_supported_property_test.cpp
+++ b/src/inference/tests/functional/get_supported_property_test.cpp
@ -33,7 +33,7 @@ public:

        injectProxyEngine(plugin.get());
        core.register_plugin(ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                                                std::string("mock_engine") + IE_BUILD_POSTFIX),
+                                                                std::string("mock_engine") + OV_BUILD_POSTFIX),
                             m_plugin_name);
        m_mock_plugin = plugin;
    }
--- a/src/inference/tests/functional/ov_core_threading.cpp
+++ b/src/inference/tests/functional/ov_core_threading.cpp
@ -64,7 +64,7 @@ public:
            OPENVINO_SUPPRESS_DEPRECATED_START
            auto extension = std::make_shared<InferenceEngine::Extension>(
                ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                                   std::string("template_extension") + IE_BUILD_POSTFIX));
+                                                   std::string("template_extension") + OV_BUILD_POSTFIX));
            core.add_extension(extension);
            OPENVINO_SUPPRESS_DEPRECATED_END
        } catch (const ov::Exception& ex) {
@ -95,7 +95,7 @@ TEST_F(CoreThreadingTests, RegisterPlugin) {
        [&]() {
            const std::string deviceName = std::to_string(index++);
            core.register_plugin(ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                                                    std::string("mock_engine") + IE_BUILD_POSTFIX),
+                                                                    std::string("mock_engine") + OV_BUILD_POSTFIX),
                                 deviceName);
            core.get_versions(deviceName);
            core.unload_plugin(deviceName);
@ -118,7 +118,7 @@ TEST_F(CoreThreadingTests, RegisterPlugins) {
        file << ov::util::FileTraits<char>::file_separator;
        file << ov::util::FileTraits<char>::library_prefix();
        file << "mock_engine";
-        file << IE_BUILD_POSTFIX;
+        file << OV_BUILD_POSTFIX;
        file << ov::util::FileTraits<char>::dot_symbol;
        file << ov::util::FileTraits<char>::library_ext();
        file << "\" name=\"";
--- a/src/inference/tests/functional/ov_extension_test.cpp
+++ b/src/inference/tests/functional/ov_extension_test.cpp
@ -15,23 +15,23 @@ namespace {

 std::string getOVExtensionPath() {
    return ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                              std::string("openvino_template_extension") + IE_BUILD_POSTFIX);
+                                              std::string("openvino_template_extension") + OV_BUILD_POSTFIX);
 }

 std::string getOldExtensionPath() {
    return ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                              std::string("template_extension") + IE_BUILD_POSTFIX);
+                                              std::string("template_extension") + OV_BUILD_POSTFIX);
 }

 std::string getIncorrectExtensionPath() {
    return ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                              std::string("incorrect") + IE_BUILD_POSTFIX);
+                                              std::string("incorrect") + OV_BUILD_POSTFIX);
 }

 std::string getRelativeOVExtensionPath() {
    std::string absolutePath =
        ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                           std::string("openvino_template_extension") + IE_BUILD_POSTFIX);
+                                           std::string("openvino_template_extension") + OV_BUILD_POSTFIX);
    return ov::test::utils::getRelativePath(ov::test::utils::getCurrentWorkingDir(), absolutePath);
 }

--- a/src/inference/tests/functional/ov_register_plugin_test.cpp
+++ b/src/inference/tests/functional/ov_register_plugin_test.cpp
@ -45,7 +45,7 @@ TEST(RegisterPluginTests, getVersionforRegisteredPluginThrows) {
    // Registered plugin with invalid so here
    ASSERT_NO_THROW(core.register_plugin(
        ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                           std::string("mock_registered_engine") + IE_BUILD_POSTFIX),
+                                           std::string("mock_registered_engine") + OV_BUILD_POSTFIX),
        mock_plugin_name));
    ASSERT_THROW(core.get_versions("MOCK_REGISTERED_HARDWARE"), ov::Exception);
 }
@ -72,7 +72,7 @@ TEST(RegisterPluginTests, getVersionforNoRegisteredPluginNoThrows) {

    ASSERT_NO_THROW(
        core.register_plugin(ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                                                std::string("mock_engine") + IE_BUILD_POSTFIX),
+                                                                std::string("mock_engine") + OV_BUILD_POSTFIX),
                             mock_plugin_name));
    ASSERT_NO_THROW(core.get_versions("MOCK_HARDWARE"));
 }
@ -87,7 +87,7 @@ TEST(RegisterPluginTests, registerNewPluginNoThrows) {
    std::string mock_plugin_name{"MOCK_HARDWARE"};
    ASSERT_NO_THROW(
        core.register_plugin(ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                                                std::string("mock_engine") + IE_BUILD_POSTFIX),
+                                                                std::string("mock_engine") + OV_BUILD_POSTFIX),
                             mock_plugin_name));
    ASSERT_NO_THROW(core.get_property(mock_plugin_name, ov::supported_properties));

@ -104,10 +104,10 @@ TEST(RegisterPluginTests, registerExistingPluginThrows) {
    std::string mock_plugin_name{"MOCK_HARDWARE"};
    ASSERT_NO_THROW(
        core.register_plugin(ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                                                std::string("mock_engine") + IE_BUILD_POSTFIX),
+                                                                std::string("mock_engine") + OV_BUILD_POSTFIX),
                             mock_plugin_name));
    ASSERT_THROW(core.register_plugin(ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                                                         std::string("mock_engine") + IE_BUILD_POSTFIX),
+                                                                         std::string("mock_engine") + OV_BUILD_POSTFIX),
                                      mock_plugin_name),
                 ov::Exception);
 }
@ -118,7 +118,7 @@ inline std::string getPluginFile() {
    std::ostringstream stream;
    stream << "<ie><plugins><plugin name=\"mock\" location=\"";
    stream << ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                                 std::string("mock_engine") + IE_BUILD_POSTFIX);
+                                                 std::string("mock_engine") + OV_BUILD_POSTFIX);
    stream << "\"></plugin></plugins></ie>";
    ov::test::utils::createFile(filename, stream.str());
    return filename;
--- a/src/inference/tests/functional/ov_shared_object_test.cpp
+++ b/src/inference/tests/functional/ov_shared_object_test.cpp
@ -16,7 +16,7 @@ class SharedObjectOVTests : public ::testing::Test {
 protected:
    std::string get_mock_engine_name() {
        return FileUtils::makePluginLibraryName<char>(ov::test::utils::getExecutableDirectory(),
-                                                      std::string("mock_engine") + IE_BUILD_POSTFIX);
+                                                      std::string("mock_engine") + OV_BUILD_POSTFIX);
    }

    void loadDll(const string& libraryName) {
--- a/src/inference/tests/unit/ie_extension_test.cpp
+++ b/src/inference/tests/unit/ie_extension_test.cpp
@ -23,7 +23,7 @@ OPENVINO_SUPPRESS_DEPRECATED_START

 static std::string getExtensionPath() {
    return FileUtils::makePluginLibraryName<char>(ov::test::utils::getExecutableDirectory(),
-                                                  std::string("template_extension") + IE_BUILD_POSTFIX);
+                                                  std::string("template_extension") + OV_BUILD_POSTFIX);
 }

 TEST(ExtensionTests, testGetOpSets) {
--- a/src/plugins/auto/tests/functional/behavior/auto_func_test.cpp
+++ b/src/plugins/auto/tests/functional/behavior/auto_func_test.cpp
@ -30,7 +30,7 @@ namespace {
 std::string get_mock_engine_path() {
    std::string mockEngineName("mock_engine");
    return ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                              mockEngineName + IE_BUILD_POSTFIX);
+                                              mockEngineName + OV_BUILD_POSTFIX);
 }

 template <class T>
@ -623,7 +623,7 @@ void ov::auto_plugin::tests::AutoFuncTests::reg_plugin(ov::Core& core,

    injectProxyEngine(plugin.get());
    core.register_plugin(ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                                            std::string("mock_engine") + IE_BUILD_POSTFIX),
+                                                            std::string("mock_engine") + OV_BUILD_POSTFIX),
                         device_name,
                         properties);
    m_mock_plugins.emplace_back(plugin);
--- a/src/plugins/hetero/tests/functional/hetero_tests.cpp
+++ b/src/plugins/hetero/tests/functional/hetero_tests.cpp
@ -32,7 +32,7 @@ namespace {
 std::string get_mock_engine_path() {
    std::string mock_engine_name("mock_engine");
    return ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                              mock_engine_name + IE_BUILD_POSTFIX);
+                                              mock_engine_name + OV_BUILD_POSTFIX);
 }

 template <class T>
--- a/src/plugins/intel_cpu/CMakeLists.txt
+++ b/src/plugins/intel_cpu/CMakeLists.txt
@ -44,7 +44,7 @@ if(X86 OR X86_64 OR AARCH64)
 else()
    set(ENABLE_MLAS_FOR_CPU_DEFAULT OFF)
 endif()
-ie_option(ENABLE_MLAS_FOR_CPU "Enable MLAS for OpenVINO CPU Plugin" ${ENABLE_MLAS_FOR_CPU_DEFAULT})
+ov_option(ENABLE_MLAS_FOR_CPU "Enable MLAS for OpenVINO CPU Plugin" ${ENABLE_MLAS_FOR_CPU_DEFAULT})

 add_subdirectory(thirdparty)

--- a/src/plugins/intel_cpu/tests/functional/extension/extension.cpp
+++ b/src/plugins/intel_cpu/tests/functional/extension/extension.cpp
@ -201,7 +201,7 @@ TEST(Extension, XmlModelWithCustomAbs) {

 static std::string get_extension_path() {
    return FileUtils::makePluginLibraryName<char>(ov::test::utils::getExecutableDirectory(),
-        std::string("template_extension") + IE_BUILD_POSTFIX);
+        std::string("template_extension") + OV_BUILD_POSTFIX);
 }


--- a/src/plugins/intel_gna/CMakeLists.txt
+++ b/src/plugins/intel_gna/CMakeLists.txt
@ -23,7 +23,7 @@ file(GLOB_RECURSE HEADERS

 # build avx2.cpp with AVX2 support, only for Windows
 if(ENABLE_AVX2 AND CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-    ie_avx2_optimization_flags(avx2_flags)
+    ov_avx2_optimization_flags(avx2_flags)
    set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/src/pre_post_process/hw_accelerated_converter_avx2.cpp PROPERTIES COMPILE_OPTIONS "${avx2_flags}")
    add_compile_definitions(HAVE_AVX2=1)
 endif()
--- a/src/plugins/intel_gna/tests/deprecated/helpers/tests_common.hpp
+++ b/src/plugins/intel_gna/tests/deprecated/helpers/tests_common.hpp
@ -44,7 +44,7 @@ protected:
    void SetUp() override;

    static std::string make_so_name(const std::string & input) {
-        return ov::test::utils::pre + input + IE_BUILD_POSTFIX + ov::test::utils::ext;
+        return ov::test::utils::pre + input + OV_BUILD_POSTFIX + ov::test::utils::ext;
    }

    void TearDown() override;
--- a/src/plugins/intel_gpu/src/graph/CMakeLists.txt
+++ b/src/plugins/intel_gpu/src/graph/CMakeLists.txt
@ -61,7 +61,7 @@ endif()
 ov_install_static_lib(${TARGET_NAME} ${OV_CPACK_COMP_CORE})

 if(ENABLE_SSE42)
-  ie_sse42_optimization_flags(sse4_2_flags)
+  ov_sse42_optimization_flags(sse4_2_flags)
  set_source_files_properties(impls/cpu/detection_output.cpp PROPERTIES
    COMPILE_FLAGS "${sse4_2_flags}"
    COMPILE_DEFINITIONS "HAVE_SSE")
--- a/src/plugins/intel_gpu/tests/unit/CMakeLists.txt
+++ b/src/plugins/intel_gpu/tests/unit/CMakeLists.txt
@ -82,7 +82,7 @@ elseif((NOT ANDROID) AND (UNIX))
 endif()

 if(ENABLE_SSE42)
-  ie_sse42_optimization_flags(sse4_2_flags)
+  ov_sse42_optimization_flags(sse4_2_flags)
  set_source_files_properties(${SOURCES_ALL} PROPERTIES COMPILE_FLAGS "${sse4_2_flags}")
 endif()

--- a/src/plugins/proxy/tests/proxy_tests.cpp
+++ b/src/plugins/proxy/tests/proxy_tests.cpp
@ -28,7 +28,7 @@ namespace {
 std::string get_mock_engine_path() {
    std::string mockEngineName("mock_engine");
    return ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                              mockEngineName + IE_BUILD_POSTFIX);
+                                              mockEngineName + OV_BUILD_POSTFIX);
 }

 template <class T>
@ -492,7 +492,7 @@ void ov::proxy::tests::ProxyTests::reg_plugin(ov::Core& core,

    injectProxyEngine(plugin.get());
    core.register_plugin(ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                                            std::string("mock_engine") + IE_BUILD_POSTFIX),
+                                                            std::string("mock_engine") + OV_BUILD_POSTFIX),
                         device_name,
                         properties);
    m_mock_plugins.emplace_back(plugin);
--- a/src/plugins/template/CMakeLists.txt
+++ b/src/plugins/template/CMakeLists.txt
@ -31,6 +31,6 @@ endif()
 # install

 if(OpenVINODeveloperPackage_FOUND)
-    ie_cpack(template)
+    ov_cpack(template)
 endif()
 # [cmake:main]
--- a/src/plugins/template/backend/CMakeLists.txt
+++ b/src/plugins/template/backend/CMakeLists.txt
@ -36,7 +36,7 @@ ov_build_target_faster(interpreter_backend UNITY)
 target_compile_definitions(interpreter_backend
    PRIVATE
        SHARED_LIB_PREFIX="${CMAKE_SHARED_LIBRARY_PREFIX}"
-        SHARED_LIB_SUFFIX="${IE_BUILD_POSTFIX}${CMAKE_SHARED_LIBRARY_SUFFIX}"
+        SHARED_LIB_SUFFIX="${OV_BUILD_POSTFIX}${CMAKE_SHARED_LIBRARY_SUFFIX}"
 )
 target_link_libraries(interpreter_backend PRIVATE openvino::builders openvino::reference openvino::util openvino::runtime::dev openvino::shape_inference)

--- a/src/tests/CMakeLists.txt
+++ b/src/tests/CMakeLists.txt
@ -2,11 +2,11 @@
 # SPDX-License-Identifier: Apache-2.0
 #

-set(IE_TESTS_ROOT ${CMAKE_CURRENT_SOURCE_DIR})
+set(OV_TESTS_ROOT ${CMAKE_CURRENT_SOURCE_DIR})

 enable_testing()

-ie_option(ENABLE_CONFORMANCE_PGQL "Enables support of PostgreSQL-based reporting from test tools" OFF)
+ov_option(ENABLE_CONFORMANCE_PGQL "Enables support of PostgreSQL-based reporting from test tools" OFF)
 mark_as_advanced(FORCE ENABLE_CONFORMANCE_PGQL)

 if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
--- a/src/tests/functional/plugin/shared/include/base/behavior_test_utils.hpp
+++ b/src/tests/functional/plugin/shared/include/base/behavior_test_utils.hpp
@ -87,7 +87,7 @@ inline InferenceEngine::Core createIECoreWithTemplate() {
    PluginCache::get().reset();
    InferenceEngine::Core ie;
 #ifndef OPENVINO_STATIC_LIBRARY
-    std::string pluginName = "openvino_template_plugin" IE_BUILD_POSTFIX;
+    std::string pluginName = "openvino_template_plugin" OV_BUILD_POSTFIX;
    ie.RegisterPlugin(ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(), pluginName),
        ov::test::utils::DEVICE_TEMPLATE);
 #endif // !OPENVINO_STATIC_LIBRARY
--- a/src/tests/functional/plugin/shared/include/base/ov_behavior_test_utils.hpp
+++ b/src/tests/functional/plugin/shared/include/base/ov_behavior_test_utils.hpp
@ -161,7 +161,7 @@ inline ov::Core createCoreWithTemplate() {
    ov::Core core;
 #ifndef OPENVINO_STATIC_LIBRARY
    std::string pluginName = "openvino_template_plugin";
-    pluginName += IE_BUILD_POSTFIX;
+    pluginName += OV_BUILD_POSTFIX;
    core.register_plugin(ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(), pluginName),
        ov::test::utils::DEVICE_TEMPLATE);
 #endif // !OPENVINO_STATIC_LIBRARY
--- a/src/tests/functional/plugin/shared/include/behavior/ov_plugin/core_integration.hpp
+++ b/src/tests/functional/plugin/shared/include/behavior/ov_plugin/core_integration.hpp
@ -65,8 +65,8 @@ public:
        std::tie(pluginName, target_device) = GetParam();
        SKIP_IF_CURRENT_TEST_IS_DISABLED();
        APIBaseTest::SetUp();
-        pluginName += IE_BUILD_POSTFIX;
-        if (pluginName == (std::string("openvino_template_plugin") + IE_BUILD_POSTFIX)) {
+        pluginName += OV_BUILD_POSTFIX;
+        if (pluginName == (std::string("openvino_template_plugin") + OV_BUILD_POSTFIX)) {
            pluginName = ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(), pluginName);
        }
    }
@ -197,7 +197,7 @@ inline std::string getPluginFile() {
    std::ostringstream stream;
    stream << "<ie><plugins><plugin name=\"mock\" location=\"";
    stream << ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-        std::string("mock_engine") + IE_BUILD_POSTFIX);
+        std::string("mock_engine") + OV_BUILD_POSTFIX);
    stream << "\"></plugin></plugins></ie>";
    ov::test::utils::createFile(filename, stream.str());
    return filename;
--- a/src/tests/functional/plugin/shared/include/behavior/ov_plugin/properties_tests.hpp
+++ b/src/tests/functional/plugin/shared/include/behavior/ov_plugin/properties_tests.hpp
@ -123,8 +123,8 @@ public:
        std::tie(pluginName, target_device) = GetParam();
        SKIP_IF_CURRENT_TEST_IS_DISABLED();
        APIBaseTest::SetUp();
-        pluginName += IE_BUILD_POSTFIX;
-        if (pluginName == (std::string("openvino_template_plugin") + IE_BUILD_POSTFIX)) {
+        pluginName += OV_BUILD_POSTFIX;
+        if (pluginName == (std::string("openvino_template_plugin") + OV_BUILD_POSTFIX)) {
            pluginName = ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(), pluginName);
        }
    }
--- a/src/tests/functional/plugin/shared/include/behavior/plugin/core_integration.hpp
+++ b/src/tests/functional/plugin/shared/include/behavior/plugin/core_integration.hpp
@ -55,8 +55,8 @@ public:
        std::tie(pluginName, target_device) = GetParam();
        SKIP_IF_CURRENT_TEST_IS_DISABLED();
        ov::test::behavior::APIBaseTest::SetUp();
-        pluginName += IE_BUILD_POSTFIX;
-        if (pluginName == (std::string("openvino_template_plugin") + IE_BUILD_POSTFIX)) {
+        pluginName += OV_BUILD_POSTFIX;
+        if (pluginName == (std::string("openvino_template_plugin") + OV_BUILD_POSTFIX)) {
            pluginName = ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(), pluginName);
        }
    }
@ -149,7 +149,7 @@ inline std::string getPluginFile() {
    std::ostringstream stream;
    stream << "<ie><plugins><plugin name=\"mock\" location=\"";
    stream << ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-        std::string("mock_engine") + IE_BUILD_POSTFIX);
+        std::string("mock_engine") + OV_BUILD_POSTFIX);
    stream << "\"></plugin></plugins></ie>";
    ov::test::utils::createFile(filename, stream.str());
    return filename;
--- a/src/tests/functional/plugin/shared/src/behavior/plugin/hetero_synthetic.cpp
+++ b/src/tests/functional/plugin/shared/src/behavior/plugin/hetero_synthetic.cpp
@ -119,11 +119,11 @@ void HeteroSyntheticTest::SetUp() {
        try {
            if (pluginParameter._location == "openvino_template_plugin") {
                PluginCache::get().ie()->RegisterPlugin(ov::util::make_plugin_library_name(
-                    ov::test::utils::getExecutableDirectory(), pluginParameter._location + IE_BUILD_POSTFIX),
+                    ov::test::utils::getExecutableDirectory(), pluginParameter._location + OV_BUILD_POSTFIX),
                    pluginParameter._name);
            } else {
                PluginCache::get().ie()->RegisterPlugin(pluginParameter._location
-                    + IE_BUILD_POSTFIX, pluginParameter._name);
+                    + OV_BUILD_POSTFIX, pluginParameter._name);
            }
        } catch (InferenceEngine::Exception& ex) {
            if (std::string{ex.what()}.find("Device with \"" + pluginParameter._name
--- a/src/tests/test_utils/common_test_utils/CMakeLists.txt
+++ b/src/tests/test_utils/common_test_utils/CMakeLists.txt
@ -79,7 +79,7 @@ function(add_common_utils ADD_TARGET_NAME)
            $<TARGET_PROPERTY:openvino::runtime,INTERFACE_INCLUDE_DIRECTORIES>
        PRIVATE
            $<TARGET_PROPERTY:openvino::runtime::dev,INTERFACE_INCLUDE_DIRECTORIES>)
-    target_include_directories(${ADD_TARGET_NAME} SYSTEM PUBLIC ${IE_TESTS_ROOT}/test_utils)
+    target_include_directories(${ADD_TARGET_NAME} SYSTEM PUBLIC ${OV_TESTS_ROOT}/test_utils)

    target_compile_definitions(${ADD_TARGET_NAME} PUBLIC ${ARGN})

--- a/src/tests/test_utils/common_test_utils/include/common_test_utils/file_utils.hpp
+++ b/src/tests/test_utils/common_test_utils/include/common_test_utils/file_utils.hpp
@ -288,7 +288,7 @@ namespace {
 inline std::string get_mock_engine_path() {
    std::string mockEngineName("mock_engine");
    return ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                              mockEngineName + IE_BUILD_POSTFIX);
+                                              mockEngineName + OV_BUILD_POSTFIX);
 }

 template <class T>
--- a/src/tests/test_utils/common_test_utils/src/test_case.cpp
+++ b/src/tests/test_utils/common_test_utils/src/test_case.cpp
@ -192,7 +192,7 @@ TestCase::TestCase(const std::shared_ptr<ov::Model>& function, const std::string
        // Register template plugin
        m_core.register_plugin(
            ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(),
-                                               std::string("openvino_template_plugin") + IE_BUILD_POSTFIX),
+                                               std::string("openvino_template_plugin") + OV_BUILD_POSTFIX),
            "TEMPLATE");
    } catch (...) {
    }
--- a/src/tests/test_utils/functional_test_utils/src/ov_plugin_cache.cpp
+++ b/src/tests/test_utils/functional_test_utils/src/ov_plugin_cache.cpp
@ -58,7 +58,7 @@ std::shared_ptr<ov::Core> PluginCache::core(const std::string& deviceToCheck) {
    // register template plugin if it is needed
    try {
        std::string pluginName = "openvino_template_plugin";
-        pluginName += IE_BUILD_POSTFIX;
+        pluginName += OV_BUILD_POSTFIX;
        ov_core->register_plugin(
            ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(), pluginName),
            "TEMPLATE");
--- a/src/tests/test_utils/functional_test_utils/src/plugin_cache.cpp
+++ b/src/tests/test_utils/functional_test_utils/src/plugin_cache.cpp
@ -57,7 +57,7 @@ std::shared_ptr<InferenceEngine::Core> PluginCache::ie(const std::string& device
    // register template plugin if it is needed
    try {
        std::string pluginName = "openvino_template_plugin";
-        pluginName += IE_BUILD_POSTFIX;
+        pluginName += OV_BUILD_POSTFIX;
        ie_core->RegisterPlugin(
            ov::util::make_plugin_library_name(ov::test::utils::getExecutableDirectory(), pluginName),
            "TEMPLATE");
--- a/tests/fuzz/CMakeLists.txt
+++ b/tests/fuzz/CMakeLists.txt
@ -11,7 +11,7 @@ set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Release" "Debug" "RelWithD

 set(OpenVINO_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../")

-find_package(IEDevScripts REQUIRED
+find_package(OpenVINODeveloperScripts REQUIRED
             PATHS "${OpenVINO_SOURCE_DIR}/cmake/developer_package"
             NO_CMAKE_FIND_ROOT_PATH
             NO_DEFAULT_PATH)
--- a/Show More
+++ b/Show More