From 1e5218ca20b0f016af8d64314a9af4782fce637f Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li@intel.com>
Date: Thu, 31 Oct 2024 15:08:23 -0700
Subject: [PATCH 01/20] Actually implement USM migration flags

---
 include/ur_api.h                              |    11 +-
 include/ur_ddi.h                              |  2530 +-
 include/ur_print.h                            |   664 +-
 include/ur_print.hpp                          | 36995 +++++++++-------
 scripts/core/enqueue.yml                      |    11 +-
 scripts/core/exp-command-buffer.yml           |     2 +-
 source/ur_api.cpp                             |  5411 ++-
 .../enqueue/enqueue_adapter_cuda.match        |     4 +-
 .../enqueue/urEnqueueUSMPrefetch.cpp          |    16 +-
 9 files changed, 26105 insertions(+), 19539 deletions(-)

diff --git a/include/ur_api.h b/include/ur_api.h
index 9897d892b6..3d8871cf98 100644
--- a/include/ur_api.h
+++ b/include/ur_api.h
@@ -6837,17 +6837,18 @@ typedef enum ur_map_flag_t {
 #define UR_MAP_FLAGS_MASK 0xfffffff8
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Map flags
+/// @brief USM migration flags, indicating the direction data is migrated in
 typedef uint32_t ur_usm_migration_flags_t;
 typedef enum ur_usm_migration_flag_t {
-    UR_USM_MIGRATION_FLAG_DEFAULT = UR_BIT(0), ///< Default migration TODO: Add more enums!
+    UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE = UR_BIT(0), ///< Migrate data from host to device
+    UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST = UR_BIT(1), ///< Migrate data from device to host
     /// @cond
     UR_USM_MIGRATION_FLAG_FORCE_UINT32 = 0x7fffffff
     /// @endcond
 
 } ur_usm_migration_flag_t;
 /// @brief Bit Mask for validating ur_usm_migration_flags_t
-#define UR_USM_MIGRATION_FLAGS_MASK 0xfffffffe
+#define UR_USM_MIGRATION_FLAGS_MASK 0xfffffffc
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to map a region of the buffer object into the host
@@ -7082,7 +7083,7 @@ urEnqueueUSMPrefetch(
     ur_queue_handle_t hQueue,                 ///< [in] handle of the queue object
     const void *pMem,                         ///< [in][bounds(0, size)] pointer to the USM memory object
     size_t size,                              ///< [in] size in bytes to be fetched
-    ur_usm_migration_flags_t flags,           ///< [in] USM prefetch flags
+    ur_usm_migration_flags_t flags,           ///< [in] USM migration flags
     uint32_t numEventsInWaitList,             ///< [in] size of the event wait list
     const ur_event_handle_t *phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
                                               ///< events that must be complete before this command can be executed.
@@ -9032,7 +9033,7 @@ urCommandBufferAppendUSMPrefetchExp(
     ur_exp_command_buffer_handle_t hCommandBuffer,                ///< [in] handle of the command-buffer object.
     const void *pMemory,                                          ///< [in] pointer to USM allocated memory to prefetch.
     size_t size,                                                  ///< [in] size in bytes to be fetched.
-    ur_usm_migration_flags_t flags,                               ///< [in] USM prefetch flags
+    ur_usm_migration_flags_t flags,                               ///< [in] USM migration flags
     uint32_t numSyncPointsInWaitList,                             ///< [in] The number of sync points in the provided dependency list.
     const ur_exp_command_buffer_sync_point_t *pSyncPointWaitList, ///< [in][optional] A list of sync points that this command depends on. May
                                                                   ///< be ignored if command-buffer is in-order.
diff --git a/include/ur_ddi.h b/include/ur_ddi.h
index b4d6f2bade..0198dd9d04 100644
--- a/include/ur_ddi.h
+++ b/include/ur_ddi.h
@@ -22,59 +22,66 @@ extern "C" {
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urPlatformGet
-typedef ur_result_t(UR_APICALL *ur_pfnPlatformGet_t)(
-    ur_adapter_handle_t *,
+/// @brief Function-pointer for urPlatformGet 
+typedef ur_result_t (UR_APICALL *ur_pfnPlatformGet_t)(
+    ur_adapter_handle_t*,
     uint32_t,
     uint32_t,
-    ur_platform_handle_t *,
-    uint32_t *);
+    ur_platform_handle_t*,
+    uint32_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urPlatformGetInfo
-typedef ur_result_t(UR_APICALL *ur_pfnPlatformGetInfo_t)(
+/// @brief Function-pointer for urPlatformGetInfo 
+typedef ur_result_t (UR_APICALL *ur_pfnPlatformGetInfo_t)(
     ur_platform_handle_t,
     ur_platform_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urPlatformGetNativeHandle
-typedef ur_result_t(UR_APICALL *ur_pfnPlatformGetNativeHandle_t)(
+/// @brief Function-pointer for urPlatformGetNativeHandle 
+typedef ur_result_t (UR_APICALL *ur_pfnPlatformGetNativeHandle_t)(
     ur_platform_handle_t,
-    ur_native_handle_t *);
+    ur_native_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urPlatformCreateWithNativeHandle
-typedef ur_result_t(UR_APICALL *ur_pfnPlatformCreateWithNativeHandle_t)(
+/// @brief Function-pointer for urPlatformCreateWithNativeHandle 
+typedef ur_result_t (UR_APICALL *ur_pfnPlatformCreateWithNativeHandle_t)(
     ur_native_handle_t,
     ur_adapter_handle_t,
-    const ur_platform_native_properties_t *,
-    ur_platform_handle_t *);
+    const ur_platform_native_properties_t*,
+    ur_platform_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urPlatformGetApiVersion
-typedef ur_result_t(UR_APICALL *ur_pfnPlatformGetApiVersion_t)(
+/// @brief Function-pointer for urPlatformGetApiVersion 
+typedef ur_result_t (UR_APICALL *ur_pfnPlatformGetApiVersion_t)(
     ur_platform_handle_t,
-    ur_api_version_t *);
+    ur_api_version_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urPlatformGetBackendOption
-typedef ur_result_t(UR_APICALL *ur_pfnPlatformGetBackendOption_t)(
+/// @brief Function-pointer for urPlatformGetBackendOption 
+typedef ur_result_t (UR_APICALL *ur_pfnPlatformGetBackendOption_t)(
     ur_platform_handle_t,
-    const char *,
-    const char **);
+    const char*,
+    const char**
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of Platform functions pointers
-typedef struct ur_platform_dditable_t {
-    ur_pfnPlatformGet_t pfnGet;
-    ur_pfnPlatformGetInfo_t pfnGetInfo;
-    ur_pfnPlatformGetNativeHandle_t pfnGetNativeHandle;
-    ur_pfnPlatformCreateWithNativeHandle_t pfnCreateWithNativeHandle;
-    ur_pfnPlatformGetApiVersion_t pfnGetApiVersion;
-    ur_pfnPlatformGetBackendOption_t pfnGetBackendOption;
+typedef struct ur_platform_dditable_t
+{
+    ur_pfnPlatformGet_t                                         pfnGet;
+    ur_pfnPlatformGetInfo_t                                     pfnGetInfo;
+    ur_pfnPlatformGetNativeHandle_t                             pfnGetNativeHandle;
+    ur_pfnPlatformCreateWithNativeHandle_t                      pfnCreateWithNativeHandle;
+    ur_pfnPlatformGetApiVersion_t                               pfnGetApiVersion;
+    ur_pfnPlatformGetBackendOption_t                            pfnGetBackendOption;
 } ur_platform_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -88,76 +95,85 @@ typedef struct ur_platform_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetPlatformProcAddrTable(
-    ur_api_version_t version,         ///< [in] API version requested
-    ur_platform_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_platform_dditable_t* pDdiTable               ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetPlatformProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetPlatformProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetPlatformProcAddrTable_t)(
     ur_api_version_t,
-    ur_platform_dditable_t *);
+    ur_platform_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urContextCreate
-typedef ur_result_t(UR_APICALL *ur_pfnContextCreate_t)(
+/// @brief Function-pointer for urContextCreate 
+typedef ur_result_t (UR_APICALL *ur_pfnContextCreate_t)(
     uint32_t,
-    const ur_device_handle_t *,
-    const ur_context_properties_t *,
-    ur_context_handle_t *);
+    const ur_device_handle_t*,
+    const ur_context_properties_t*,
+    ur_context_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urContextRetain
-typedef ur_result_t(UR_APICALL *ur_pfnContextRetain_t)(
-    ur_context_handle_t);
+/// @brief Function-pointer for urContextRetain 
+typedef ur_result_t (UR_APICALL *ur_pfnContextRetain_t)(
+    ur_context_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urContextRelease
-typedef ur_result_t(UR_APICALL *ur_pfnContextRelease_t)(
-    ur_context_handle_t);
+/// @brief Function-pointer for urContextRelease 
+typedef ur_result_t (UR_APICALL *ur_pfnContextRelease_t)(
+    ur_context_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urContextGetInfo
-typedef ur_result_t(UR_APICALL *ur_pfnContextGetInfo_t)(
+/// @brief Function-pointer for urContextGetInfo 
+typedef ur_result_t (UR_APICALL *ur_pfnContextGetInfo_t)(
     ur_context_handle_t,
     ur_context_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urContextGetNativeHandle
-typedef ur_result_t(UR_APICALL *ur_pfnContextGetNativeHandle_t)(
+/// @brief Function-pointer for urContextGetNativeHandle 
+typedef ur_result_t (UR_APICALL *ur_pfnContextGetNativeHandle_t)(
     ur_context_handle_t,
-    ur_native_handle_t *);
+    ur_native_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urContextCreateWithNativeHandle
-typedef ur_result_t(UR_APICALL *ur_pfnContextCreateWithNativeHandle_t)(
+/// @brief Function-pointer for urContextCreateWithNativeHandle 
+typedef ur_result_t (UR_APICALL *ur_pfnContextCreateWithNativeHandle_t)(
     ur_native_handle_t,
     ur_adapter_handle_t,
     uint32_t,
-    const ur_device_handle_t *,
-    const ur_context_native_properties_t *,
-    ur_context_handle_t *);
+    const ur_device_handle_t*,
+    const ur_context_native_properties_t*,
+    ur_context_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urContextSetExtendedDeleter
-typedef ur_result_t(UR_APICALL *ur_pfnContextSetExtendedDeleter_t)(
+/// @brief Function-pointer for urContextSetExtendedDeleter 
+typedef ur_result_t (UR_APICALL *ur_pfnContextSetExtendedDeleter_t)(
     ur_context_handle_t,
     ur_context_extended_deleter_t,
-    void *);
+    void*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of Context functions pointers
-typedef struct ur_context_dditable_t {
-    ur_pfnContextCreate_t pfnCreate;
-    ur_pfnContextRetain_t pfnRetain;
-    ur_pfnContextRelease_t pfnRelease;
-    ur_pfnContextGetInfo_t pfnGetInfo;
-    ur_pfnContextGetNativeHandle_t pfnGetNativeHandle;
-    ur_pfnContextCreateWithNativeHandle_t pfnCreateWithNativeHandle;
-    ur_pfnContextSetExtendedDeleter_t pfnSetExtendedDeleter;
+typedef struct ur_context_dditable_t
+{
+    ur_pfnContextCreate_t                                       pfnCreate;
+    ur_pfnContextRetain_t                                       pfnRetain;
+    ur_pfnContextRelease_t                                      pfnRelease;
+    ur_pfnContextGetInfo_t                                      pfnGetInfo;
+    ur_pfnContextGetNativeHandle_t                              pfnGetNativeHandle;
+    ur_pfnContextCreateWithNativeHandle_t                       pfnCreateWithNativeHandle;
+    ur_pfnContextSetExtendedDeleter_t                           pfnSetExtendedDeleter;
 } ur_context_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -171,83 +187,93 @@ typedef struct ur_context_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetContextProcAddrTable(
-    ur_api_version_t version,        ///< [in] API version requested
-    ur_context_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_context_dditable_t* pDdiTable                ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetContextProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetContextProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetContextProcAddrTable_t)(
     ur_api_version_t,
-    ur_context_dditable_t *);
+    ur_context_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEventGetInfo
-typedef ur_result_t(UR_APICALL *ur_pfnEventGetInfo_t)(
+/// @brief Function-pointer for urEventGetInfo 
+typedef ur_result_t (UR_APICALL *ur_pfnEventGetInfo_t)(
     ur_event_handle_t,
     ur_event_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEventGetProfilingInfo
-typedef ur_result_t(UR_APICALL *ur_pfnEventGetProfilingInfo_t)(
+/// @brief Function-pointer for urEventGetProfilingInfo 
+typedef ur_result_t (UR_APICALL *ur_pfnEventGetProfilingInfo_t)(
     ur_event_handle_t,
     ur_profiling_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEventWait
-typedef ur_result_t(UR_APICALL *ur_pfnEventWait_t)(
+/// @brief Function-pointer for urEventWait 
+typedef ur_result_t (UR_APICALL *ur_pfnEventWait_t)(
     uint32_t,
-    const ur_event_handle_t *);
+    const ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEventRetain
-typedef ur_result_t(UR_APICALL *ur_pfnEventRetain_t)(
-    ur_event_handle_t);
+/// @brief Function-pointer for urEventRetain 
+typedef ur_result_t (UR_APICALL *ur_pfnEventRetain_t)(
+    ur_event_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEventRelease
-typedef ur_result_t(UR_APICALL *ur_pfnEventRelease_t)(
-    ur_event_handle_t);
+/// @brief Function-pointer for urEventRelease 
+typedef ur_result_t (UR_APICALL *ur_pfnEventRelease_t)(
+    ur_event_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEventGetNativeHandle
-typedef ur_result_t(UR_APICALL *ur_pfnEventGetNativeHandle_t)(
+/// @brief Function-pointer for urEventGetNativeHandle 
+typedef ur_result_t (UR_APICALL *ur_pfnEventGetNativeHandle_t)(
     ur_event_handle_t,
-    ur_native_handle_t *);
+    ur_native_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEventCreateWithNativeHandle
-typedef ur_result_t(UR_APICALL *ur_pfnEventCreateWithNativeHandle_t)(
+/// @brief Function-pointer for urEventCreateWithNativeHandle 
+typedef ur_result_t (UR_APICALL *ur_pfnEventCreateWithNativeHandle_t)(
     ur_native_handle_t,
     ur_context_handle_t,
-    const ur_event_native_properties_t *,
-    ur_event_handle_t *);
+    const ur_event_native_properties_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEventSetCallback
-typedef ur_result_t(UR_APICALL *ur_pfnEventSetCallback_t)(
+/// @brief Function-pointer for urEventSetCallback 
+typedef ur_result_t (UR_APICALL *ur_pfnEventSetCallback_t)(
     ur_event_handle_t,
     ur_execution_info_t,
     ur_event_callback_t,
-    void *);
+    void*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of Event functions pointers
-typedef struct ur_event_dditable_t {
-    ur_pfnEventGetInfo_t pfnGetInfo;
-    ur_pfnEventGetProfilingInfo_t pfnGetProfilingInfo;
-    ur_pfnEventWait_t pfnWait;
-    ur_pfnEventRetain_t pfnRetain;
-    ur_pfnEventRelease_t pfnRelease;
-    ur_pfnEventGetNativeHandle_t pfnGetNativeHandle;
-    ur_pfnEventCreateWithNativeHandle_t pfnCreateWithNativeHandle;
-    ur_pfnEventSetCallback_t pfnSetCallback;
+typedef struct ur_event_dditable_t
+{
+    ur_pfnEventGetInfo_t                                        pfnGetInfo;
+    ur_pfnEventGetProfilingInfo_t                               pfnGetProfilingInfo;
+    ur_pfnEventWait_t                                           pfnWait;
+    ur_pfnEventRetain_t                                         pfnRetain;
+    ur_pfnEventRelease_t                                        pfnRelease;
+    ur_pfnEventGetNativeHandle_t                                pfnGetNativeHandle;
+    ur_pfnEventCreateWithNativeHandle_t                         pfnCreateWithNativeHandle;
+    ur_pfnEventSetCallback_t                                    pfnSetCallback;
 } ur_event_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -261,142 +287,158 @@ typedef struct ur_event_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetEventProcAddrTable(
-    ur_api_version_t version,      ///< [in] API version requested
-    ur_event_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_event_dditable_t* pDdiTable                  ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetEventProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetEventProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetEventProcAddrTable_t)(
     ur_api_version_t,
-    ur_event_dditable_t *);
+    ur_event_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urProgramCreateWithIL
-typedef ur_result_t(UR_APICALL *ur_pfnProgramCreateWithIL_t)(
+/// @brief Function-pointer for urProgramCreateWithIL 
+typedef ur_result_t (UR_APICALL *ur_pfnProgramCreateWithIL_t)(
     ur_context_handle_t,
-    const void *,
+    const void*,
     size_t,
-    const ur_program_properties_t *,
-    ur_program_handle_t *);
+    const ur_program_properties_t*,
+    ur_program_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urProgramCreateWithBinary
-typedef ur_result_t(UR_APICALL *ur_pfnProgramCreateWithBinary_t)(
+/// @brief Function-pointer for urProgramCreateWithBinary 
+typedef ur_result_t (UR_APICALL *ur_pfnProgramCreateWithBinary_t)(
     ur_context_handle_t,
     ur_device_handle_t,
     size_t,
-    const uint8_t *,
-    const ur_program_properties_t *,
-    ur_program_handle_t *);
+    const uint8_t*,
+    const ur_program_properties_t*,
+    ur_program_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urProgramBuild
-typedef ur_result_t(UR_APICALL *ur_pfnProgramBuild_t)(
+/// @brief Function-pointer for urProgramBuild 
+typedef ur_result_t (UR_APICALL *ur_pfnProgramBuild_t)(
     ur_context_handle_t,
     ur_program_handle_t,
-    const char *);
+    const char*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urProgramCompile
-typedef ur_result_t(UR_APICALL *ur_pfnProgramCompile_t)(
+/// @brief Function-pointer for urProgramCompile 
+typedef ur_result_t (UR_APICALL *ur_pfnProgramCompile_t)(
     ur_context_handle_t,
     ur_program_handle_t,
-    const char *);
+    const char*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urProgramLink
-typedef ur_result_t(UR_APICALL *ur_pfnProgramLink_t)(
+/// @brief Function-pointer for urProgramLink 
+typedef ur_result_t (UR_APICALL *ur_pfnProgramLink_t)(
     ur_context_handle_t,
     uint32_t,
-    const ur_program_handle_t *,
-    const char *,
-    ur_program_handle_t *);
+    const ur_program_handle_t*,
+    const char*,
+    ur_program_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urProgramRetain
-typedef ur_result_t(UR_APICALL *ur_pfnProgramRetain_t)(
-    ur_program_handle_t);
+/// @brief Function-pointer for urProgramRetain 
+typedef ur_result_t (UR_APICALL *ur_pfnProgramRetain_t)(
+    ur_program_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urProgramRelease
-typedef ur_result_t(UR_APICALL *ur_pfnProgramRelease_t)(
-    ur_program_handle_t);
+/// @brief Function-pointer for urProgramRelease 
+typedef ur_result_t (UR_APICALL *ur_pfnProgramRelease_t)(
+    ur_program_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urProgramGetFunctionPointer
-typedef ur_result_t(UR_APICALL *ur_pfnProgramGetFunctionPointer_t)(
+/// @brief Function-pointer for urProgramGetFunctionPointer 
+typedef ur_result_t (UR_APICALL *ur_pfnProgramGetFunctionPointer_t)(
     ur_device_handle_t,
     ur_program_handle_t,
-    const char *,
-    void **);
+    const char*,
+    void**
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urProgramGetGlobalVariablePointer
-typedef ur_result_t(UR_APICALL *ur_pfnProgramGetGlobalVariablePointer_t)(
+/// @brief Function-pointer for urProgramGetGlobalVariablePointer 
+typedef ur_result_t (UR_APICALL *ur_pfnProgramGetGlobalVariablePointer_t)(
     ur_device_handle_t,
     ur_program_handle_t,
-    const char *,
-    size_t *,
-    void **);
+    const char*,
+    size_t*,
+    void**
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urProgramGetInfo
-typedef ur_result_t(UR_APICALL *ur_pfnProgramGetInfo_t)(
+/// @brief Function-pointer for urProgramGetInfo 
+typedef ur_result_t (UR_APICALL *ur_pfnProgramGetInfo_t)(
     ur_program_handle_t,
     ur_program_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urProgramGetBuildInfo
-typedef ur_result_t(UR_APICALL *ur_pfnProgramGetBuildInfo_t)(
+/// @brief Function-pointer for urProgramGetBuildInfo 
+typedef ur_result_t (UR_APICALL *ur_pfnProgramGetBuildInfo_t)(
     ur_program_handle_t,
     ur_device_handle_t,
     ur_program_build_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urProgramSetSpecializationConstants
-typedef ur_result_t(UR_APICALL *ur_pfnProgramSetSpecializationConstants_t)(
+/// @brief Function-pointer for urProgramSetSpecializationConstants 
+typedef ur_result_t (UR_APICALL *ur_pfnProgramSetSpecializationConstants_t)(
     ur_program_handle_t,
     uint32_t,
-    const ur_specialization_constant_info_t *);
+    const ur_specialization_constant_info_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urProgramGetNativeHandle
-typedef ur_result_t(UR_APICALL *ur_pfnProgramGetNativeHandle_t)(
+/// @brief Function-pointer for urProgramGetNativeHandle 
+typedef ur_result_t (UR_APICALL *ur_pfnProgramGetNativeHandle_t)(
     ur_program_handle_t,
-    ur_native_handle_t *);
+    ur_native_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urProgramCreateWithNativeHandle
-typedef ur_result_t(UR_APICALL *ur_pfnProgramCreateWithNativeHandle_t)(
+/// @brief Function-pointer for urProgramCreateWithNativeHandle 
+typedef ur_result_t (UR_APICALL *ur_pfnProgramCreateWithNativeHandle_t)(
     ur_native_handle_t,
     ur_context_handle_t,
-    const ur_program_native_properties_t *,
-    ur_program_handle_t *);
+    const ur_program_native_properties_t*,
+    ur_program_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of Program functions pointers
-typedef struct ur_program_dditable_t {
-    ur_pfnProgramCreateWithIL_t pfnCreateWithIL;
-    ur_pfnProgramCreateWithBinary_t pfnCreateWithBinary;
-    ur_pfnProgramBuild_t pfnBuild;
-    ur_pfnProgramCompile_t pfnCompile;
-    ur_pfnProgramLink_t pfnLink;
-    ur_pfnProgramRetain_t pfnRetain;
-    ur_pfnProgramRelease_t pfnRelease;
-    ur_pfnProgramGetFunctionPointer_t pfnGetFunctionPointer;
-    ur_pfnProgramGetGlobalVariablePointer_t pfnGetGlobalVariablePointer;
-    ur_pfnProgramGetInfo_t pfnGetInfo;
-    ur_pfnProgramGetBuildInfo_t pfnGetBuildInfo;
-    ur_pfnProgramSetSpecializationConstants_t pfnSetSpecializationConstants;
-    ur_pfnProgramGetNativeHandle_t pfnGetNativeHandle;
-    ur_pfnProgramCreateWithNativeHandle_t pfnCreateWithNativeHandle;
+typedef struct ur_program_dditable_t
+{
+    ur_pfnProgramCreateWithIL_t                                 pfnCreateWithIL;
+    ur_pfnProgramCreateWithBinary_t                             pfnCreateWithBinary;
+    ur_pfnProgramBuild_t                                        pfnBuild;
+    ur_pfnProgramCompile_t                                      pfnCompile;
+    ur_pfnProgramLink_t                                         pfnLink;
+    ur_pfnProgramRetain_t                                       pfnRetain;
+    ur_pfnProgramRelease_t                                      pfnRelease;
+    ur_pfnProgramGetFunctionPointer_t                           pfnGetFunctionPointer;
+    ur_pfnProgramGetGlobalVariablePointer_t                     pfnGetGlobalVariablePointer;
+    ur_pfnProgramGetInfo_t                                      pfnGetInfo;
+    ur_pfnProgramGetBuildInfo_t                                 pfnGetBuildInfo;
+    ur_pfnProgramSetSpecializationConstants_t                   pfnSetSpecializationConstants;
+    ur_pfnProgramGetNativeHandle_t                              pfnGetNativeHandle;
+    ur_pfnProgramCreateWithNativeHandle_t                       pfnCreateWithNativeHandle;
 } ur_program_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -410,49 +452,54 @@ typedef struct ur_program_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetProgramProcAddrTable(
-    ur_api_version_t version,        ///< [in] API version requested
-    ur_program_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_program_dditable_t* pDdiTable                ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetProgramProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetProgramProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetProgramProcAddrTable_t)(
     ur_api_version_t,
-    ur_program_dditable_t *);
+    ur_program_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urProgramBuildExp
-typedef ur_result_t(UR_APICALL *ur_pfnProgramBuildExp_t)(
+/// @brief Function-pointer for urProgramBuildExp 
+typedef ur_result_t (UR_APICALL *ur_pfnProgramBuildExp_t)(
     ur_program_handle_t,
     uint32_t,
-    ur_device_handle_t *,
-    const char *);
+    ur_device_handle_t*,
+    const char*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urProgramCompileExp
-typedef ur_result_t(UR_APICALL *ur_pfnProgramCompileExp_t)(
+/// @brief Function-pointer for urProgramCompileExp 
+typedef ur_result_t (UR_APICALL *ur_pfnProgramCompileExp_t)(
     ur_program_handle_t,
     uint32_t,
-    ur_device_handle_t *,
-    const char *);
+    ur_device_handle_t*,
+    const char*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urProgramLinkExp
-typedef ur_result_t(UR_APICALL *ur_pfnProgramLinkExp_t)(
+/// @brief Function-pointer for urProgramLinkExp 
+typedef ur_result_t (UR_APICALL *ur_pfnProgramLinkExp_t)(
     ur_context_handle_t,
     uint32_t,
-    ur_device_handle_t *,
+    ur_device_handle_t*,
     uint32_t,
-    const ur_program_handle_t *,
-    const char *,
-    ur_program_handle_t *);
+    const ur_program_handle_t*,
+    const char*,
+    ur_program_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of ProgramExp functions pointers
-typedef struct ur_program_exp_dditable_t {
-    ur_pfnProgramBuildExp_t pfnBuildExp;
-    ur_pfnProgramCompileExp_t pfnCompileExp;
-    ur_pfnProgramLinkExp_t pfnLinkExp;
+typedef struct ur_program_exp_dditable_t
+{
+    ur_pfnProgramBuildExp_t                                     pfnBuildExp;
+    ur_pfnProgramCompileExp_t                                   pfnCompileExp;
+    ur_pfnProgramLinkExp_t                                      pfnLinkExp;
 } ur_program_exp_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -466,163 +513,181 @@ typedef struct ur_program_exp_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetProgramExpProcAddrTable(
-    ur_api_version_t version,            ///< [in] API version requested
-    ur_program_exp_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_program_exp_dditable_t* pDdiTable            ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetProgramExpProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetProgramExpProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetProgramExpProcAddrTable_t)(
     ur_api_version_t,
-    ur_program_exp_dditable_t *);
+    ur_program_exp_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urKernelCreate
-typedef ur_result_t(UR_APICALL *ur_pfnKernelCreate_t)(
+/// @brief Function-pointer for urKernelCreate 
+typedef ur_result_t (UR_APICALL *ur_pfnKernelCreate_t)(
     ur_program_handle_t,
-    const char *,
-    ur_kernel_handle_t *);
+    const char*,
+    ur_kernel_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urKernelGetInfo
-typedef ur_result_t(UR_APICALL *ur_pfnKernelGetInfo_t)(
+/// @brief Function-pointer for urKernelGetInfo 
+typedef ur_result_t (UR_APICALL *ur_pfnKernelGetInfo_t)(
     ur_kernel_handle_t,
     ur_kernel_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urKernelGetGroupInfo
-typedef ur_result_t(UR_APICALL *ur_pfnKernelGetGroupInfo_t)(
+/// @brief Function-pointer for urKernelGetGroupInfo 
+typedef ur_result_t (UR_APICALL *ur_pfnKernelGetGroupInfo_t)(
     ur_kernel_handle_t,
     ur_device_handle_t,
     ur_kernel_group_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urKernelGetSubGroupInfo
-typedef ur_result_t(UR_APICALL *ur_pfnKernelGetSubGroupInfo_t)(
+/// @brief Function-pointer for urKernelGetSubGroupInfo 
+typedef ur_result_t (UR_APICALL *ur_pfnKernelGetSubGroupInfo_t)(
     ur_kernel_handle_t,
     ur_device_handle_t,
     ur_kernel_sub_group_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urKernelRetain
-typedef ur_result_t(UR_APICALL *ur_pfnKernelRetain_t)(
-    ur_kernel_handle_t);
+/// @brief Function-pointer for urKernelRetain 
+typedef ur_result_t (UR_APICALL *ur_pfnKernelRetain_t)(
+    ur_kernel_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urKernelRelease
-typedef ur_result_t(UR_APICALL *ur_pfnKernelRelease_t)(
-    ur_kernel_handle_t);
+/// @brief Function-pointer for urKernelRelease 
+typedef ur_result_t (UR_APICALL *ur_pfnKernelRelease_t)(
+    ur_kernel_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urKernelGetNativeHandle
-typedef ur_result_t(UR_APICALL *ur_pfnKernelGetNativeHandle_t)(
+/// @brief Function-pointer for urKernelGetNativeHandle 
+typedef ur_result_t (UR_APICALL *ur_pfnKernelGetNativeHandle_t)(
     ur_kernel_handle_t,
-    ur_native_handle_t *);
+    ur_native_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urKernelCreateWithNativeHandle
-typedef ur_result_t(UR_APICALL *ur_pfnKernelCreateWithNativeHandle_t)(
+/// @brief Function-pointer for urKernelCreateWithNativeHandle 
+typedef ur_result_t (UR_APICALL *ur_pfnKernelCreateWithNativeHandle_t)(
     ur_native_handle_t,
     ur_context_handle_t,
     ur_program_handle_t,
-    const ur_kernel_native_properties_t *,
-    ur_kernel_handle_t *);
+    const ur_kernel_native_properties_t*,
+    ur_kernel_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urKernelGetSuggestedLocalWorkSize
-typedef ur_result_t(UR_APICALL *ur_pfnKernelGetSuggestedLocalWorkSize_t)(
+/// @brief Function-pointer for urKernelGetSuggestedLocalWorkSize 
+typedef ur_result_t (UR_APICALL *ur_pfnKernelGetSuggestedLocalWorkSize_t)(
     ur_kernel_handle_t,
     ur_queue_handle_t,
     uint32_t,
-    const size_t *,
-    const size_t *,
-    size_t *);
+    const size_t*,
+    const size_t*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urKernelSetArgValue
-typedef ur_result_t(UR_APICALL *ur_pfnKernelSetArgValue_t)(
+/// @brief Function-pointer for urKernelSetArgValue 
+typedef ur_result_t (UR_APICALL *ur_pfnKernelSetArgValue_t)(
     ur_kernel_handle_t,
     uint32_t,
     size_t,
-    const ur_kernel_arg_value_properties_t *,
-    const void *);
+    const ur_kernel_arg_value_properties_t*,
+    const void*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urKernelSetArgLocal
-typedef ur_result_t(UR_APICALL *ur_pfnKernelSetArgLocal_t)(
+/// @brief Function-pointer for urKernelSetArgLocal 
+typedef ur_result_t (UR_APICALL *ur_pfnKernelSetArgLocal_t)(
     ur_kernel_handle_t,
     uint32_t,
     size_t,
-    const ur_kernel_arg_local_properties_t *);
+    const ur_kernel_arg_local_properties_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urKernelSetArgPointer
-typedef ur_result_t(UR_APICALL *ur_pfnKernelSetArgPointer_t)(
+/// @brief Function-pointer for urKernelSetArgPointer 
+typedef ur_result_t (UR_APICALL *ur_pfnKernelSetArgPointer_t)(
     ur_kernel_handle_t,
     uint32_t,
-    const ur_kernel_arg_pointer_properties_t *,
-    const void *);
+    const ur_kernel_arg_pointer_properties_t*,
+    const void*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urKernelSetExecInfo
-typedef ur_result_t(UR_APICALL *ur_pfnKernelSetExecInfo_t)(
+/// @brief Function-pointer for urKernelSetExecInfo 
+typedef ur_result_t (UR_APICALL *ur_pfnKernelSetExecInfo_t)(
     ur_kernel_handle_t,
     ur_kernel_exec_info_t,
     size_t,
-    const ur_kernel_exec_info_properties_t *,
-    const void *);
+    const ur_kernel_exec_info_properties_t*,
+    const void*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urKernelSetArgSampler
-typedef ur_result_t(UR_APICALL *ur_pfnKernelSetArgSampler_t)(
+/// @brief Function-pointer for urKernelSetArgSampler 
+typedef ur_result_t (UR_APICALL *ur_pfnKernelSetArgSampler_t)(
     ur_kernel_handle_t,
     uint32_t,
-    const ur_kernel_arg_sampler_properties_t *,
-    ur_sampler_handle_t);
+    const ur_kernel_arg_sampler_properties_t*,
+    ur_sampler_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urKernelSetArgMemObj
-typedef ur_result_t(UR_APICALL *ur_pfnKernelSetArgMemObj_t)(
+/// @brief Function-pointer for urKernelSetArgMemObj 
+typedef ur_result_t (UR_APICALL *ur_pfnKernelSetArgMemObj_t)(
     ur_kernel_handle_t,
     uint32_t,
-    const ur_kernel_arg_mem_obj_properties_t *,
-    ur_mem_handle_t);
+    const ur_kernel_arg_mem_obj_properties_t*,
+    ur_mem_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urKernelSetSpecializationConstants
-typedef ur_result_t(UR_APICALL *ur_pfnKernelSetSpecializationConstants_t)(
+/// @brief Function-pointer for urKernelSetSpecializationConstants 
+typedef ur_result_t (UR_APICALL *ur_pfnKernelSetSpecializationConstants_t)(
     ur_kernel_handle_t,
     uint32_t,
-    const ur_specialization_constant_info_t *);
+    const ur_specialization_constant_info_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of Kernel functions pointers
-typedef struct ur_kernel_dditable_t {
-    ur_pfnKernelCreate_t pfnCreate;
-    ur_pfnKernelGetInfo_t pfnGetInfo;
-    ur_pfnKernelGetGroupInfo_t pfnGetGroupInfo;
-    ur_pfnKernelGetSubGroupInfo_t pfnGetSubGroupInfo;
-    ur_pfnKernelRetain_t pfnRetain;
-    ur_pfnKernelRelease_t pfnRelease;
-    ur_pfnKernelGetNativeHandle_t pfnGetNativeHandle;
-    ur_pfnKernelCreateWithNativeHandle_t pfnCreateWithNativeHandle;
-    ur_pfnKernelGetSuggestedLocalWorkSize_t pfnGetSuggestedLocalWorkSize;
-    ur_pfnKernelSetArgValue_t pfnSetArgValue;
-    ur_pfnKernelSetArgLocal_t pfnSetArgLocal;
-    ur_pfnKernelSetArgPointer_t pfnSetArgPointer;
-    ur_pfnKernelSetExecInfo_t pfnSetExecInfo;
-    ur_pfnKernelSetArgSampler_t pfnSetArgSampler;
-    ur_pfnKernelSetArgMemObj_t pfnSetArgMemObj;
-    ur_pfnKernelSetSpecializationConstants_t pfnSetSpecializationConstants;
+typedef struct ur_kernel_dditable_t
+{
+    ur_pfnKernelCreate_t                                        pfnCreate;
+    ur_pfnKernelGetInfo_t                                       pfnGetInfo;
+    ur_pfnKernelGetGroupInfo_t                                  pfnGetGroupInfo;
+    ur_pfnKernelGetSubGroupInfo_t                               pfnGetSubGroupInfo;
+    ur_pfnKernelRetain_t                                        pfnRetain;
+    ur_pfnKernelRelease_t                                       pfnRelease;
+    ur_pfnKernelGetNativeHandle_t                               pfnGetNativeHandle;
+    ur_pfnKernelCreateWithNativeHandle_t                        pfnCreateWithNativeHandle;
+    ur_pfnKernelGetSuggestedLocalWorkSize_t                     pfnGetSuggestedLocalWorkSize;
+    ur_pfnKernelSetArgValue_t                                   pfnSetArgValue;
+    ur_pfnKernelSetArgLocal_t                                   pfnSetArgLocal;
+    ur_pfnKernelSetArgPointer_t                                 pfnSetArgPointer;
+    ur_pfnKernelSetExecInfo_t                                   pfnSetExecInfo;
+    ur_pfnKernelSetArgSampler_t                                 pfnSetArgSampler;
+    ur_pfnKernelSetArgMemObj_t                                  pfnSetArgMemObj;
+    ur_pfnKernelSetSpecializationConstants_t                    pfnSetSpecializationConstants;
 } ur_kernel_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -636,28 +701,31 @@ typedef struct ur_kernel_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetKernelProcAddrTable(
-    ur_api_version_t version,       ///< [in] API version requested
-    ur_kernel_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_kernel_dditable_t* pDdiTable                 ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetKernelProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetKernelProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetKernelProcAddrTable_t)(
     ur_api_version_t,
-    ur_kernel_dditable_t *);
+    ur_kernel_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urKernelSuggestMaxCooperativeGroupCountExp
-typedef ur_result_t(UR_APICALL *ur_pfnKernelSuggestMaxCooperativeGroupCountExp_t)(
+/// @brief Function-pointer for urKernelSuggestMaxCooperativeGroupCountExp 
+typedef ur_result_t (UR_APICALL *ur_pfnKernelSuggestMaxCooperativeGroupCountExp_t)(
     ur_kernel_handle_t,
     size_t,
     size_t,
-    uint32_t *);
+    uint32_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of KernelExp functions pointers
-typedef struct ur_kernel_exp_dditable_t {
-    ur_pfnKernelSuggestMaxCooperativeGroupCountExp_t pfnSuggestMaxCooperativeGroupCountExp;
+typedef struct ur_kernel_exp_dditable_t
+{
+    ur_pfnKernelSuggestMaxCooperativeGroupCountExp_t            pfnSuggestMaxCooperativeGroupCountExp;
 } ur_kernel_exp_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -671,80 +739,90 @@ typedef struct ur_kernel_exp_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetKernelExpProcAddrTable(
-    ur_api_version_t version,           ///< [in] API version requested
-    ur_kernel_exp_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_kernel_exp_dditable_t* pDdiTable             ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetKernelExpProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetKernelExpProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetKernelExpProcAddrTable_t)(
     ur_api_version_t,
-    ur_kernel_exp_dditable_t *);
+    ur_kernel_exp_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urQueueGetInfo
-typedef ur_result_t(UR_APICALL *ur_pfnQueueGetInfo_t)(
+/// @brief Function-pointer for urQueueGetInfo 
+typedef ur_result_t (UR_APICALL *ur_pfnQueueGetInfo_t)(
     ur_queue_handle_t,
     ur_queue_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urQueueCreate
-typedef ur_result_t(UR_APICALL *ur_pfnQueueCreate_t)(
+/// @brief Function-pointer for urQueueCreate 
+typedef ur_result_t (UR_APICALL *ur_pfnQueueCreate_t)(
     ur_context_handle_t,
     ur_device_handle_t,
-    const ur_queue_properties_t *,
-    ur_queue_handle_t *);
+    const ur_queue_properties_t*,
+    ur_queue_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urQueueRetain
-typedef ur_result_t(UR_APICALL *ur_pfnQueueRetain_t)(
-    ur_queue_handle_t);
+/// @brief Function-pointer for urQueueRetain 
+typedef ur_result_t (UR_APICALL *ur_pfnQueueRetain_t)(
+    ur_queue_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urQueueRelease
-typedef ur_result_t(UR_APICALL *ur_pfnQueueRelease_t)(
-    ur_queue_handle_t);
+/// @brief Function-pointer for urQueueRelease 
+typedef ur_result_t (UR_APICALL *ur_pfnQueueRelease_t)(
+    ur_queue_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urQueueGetNativeHandle
-typedef ur_result_t(UR_APICALL *ur_pfnQueueGetNativeHandle_t)(
+/// @brief Function-pointer for urQueueGetNativeHandle 
+typedef ur_result_t (UR_APICALL *ur_pfnQueueGetNativeHandle_t)(
     ur_queue_handle_t,
-    ur_queue_native_desc_t *,
-    ur_native_handle_t *);
+    ur_queue_native_desc_t*,
+    ur_native_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urQueueCreateWithNativeHandle
-typedef ur_result_t(UR_APICALL *ur_pfnQueueCreateWithNativeHandle_t)(
+/// @brief Function-pointer for urQueueCreateWithNativeHandle 
+typedef ur_result_t (UR_APICALL *ur_pfnQueueCreateWithNativeHandle_t)(
     ur_native_handle_t,
     ur_context_handle_t,
     ur_device_handle_t,
-    const ur_queue_native_properties_t *,
-    ur_queue_handle_t *);
+    const ur_queue_native_properties_t*,
+    ur_queue_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urQueueFinish
-typedef ur_result_t(UR_APICALL *ur_pfnQueueFinish_t)(
-    ur_queue_handle_t);
+/// @brief Function-pointer for urQueueFinish 
+typedef ur_result_t (UR_APICALL *ur_pfnQueueFinish_t)(
+    ur_queue_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urQueueFlush
-typedef ur_result_t(UR_APICALL *ur_pfnQueueFlush_t)(
-    ur_queue_handle_t);
+/// @brief Function-pointer for urQueueFlush 
+typedef ur_result_t (UR_APICALL *ur_pfnQueueFlush_t)(
+    ur_queue_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of Queue functions pointers
-typedef struct ur_queue_dditable_t {
-    ur_pfnQueueGetInfo_t pfnGetInfo;
-    ur_pfnQueueCreate_t pfnCreate;
-    ur_pfnQueueRetain_t pfnRetain;
-    ur_pfnQueueRelease_t pfnRelease;
-    ur_pfnQueueGetNativeHandle_t pfnGetNativeHandle;
-    ur_pfnQueueCreateWithNativeHandle_t pfnCreateWithNativeHandle;
-    ur_pfnQueueFinish_t pfnFinish;
-    ur_pfnQueueFlush_t pfnFlush;
+typedef struct ur_queue_dditable_t
+{
+    ur_pfnQueueGetInfo_t                                        pfnGetInfo;
+    ur_pfnQueueCreate_t                                         pfnCreate;
+    ur_pfnQueueRetain_t                                         pfnRetain;
+    ur_pfnQueueRelease_t                                        pfnRelease;
+    ur_pfnQueueGetNativeHandle_t                                pfnGetNativeHandle;
+    ur_pfnQueueCreateWithNativeHandle_t                         pfnCreateWithNativeHandle;
+    ur_pfnQueueFinish_t                                         pfnFinish;
+    ur_pfnQueueFlush_t                                          pfnFlush;
 } ur_queue_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -758,65 +836,73 @@ typedef struct ur_queue_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetQueueProcAddrTable(
-    ur_api_version_t version,      ///< [in] API version requested
-    ur_queue_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_queue_dditable_t* pDdiTable                  ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetQueueProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetQueueProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetQueueProcAddrTable_t)(
     ur_api_version_t,
-    ur_queue_dditable_t *);
+    ur_queue_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urSamplerCreate
-typedef ur_result_t(UR_APICALL *ur_pfnSamplerCreate_t)(
+/// @brief Function-pointer for urSamplerCreate 
+typedef ur_result_t (UR_APICALL *ur_pfnSamplerCreate_t)(
     ur_context_handle_t,
-    const ur_sampler_desc_t *,
-    ur_sampler_handle_t *);
+    const ur_sampler_desc_t*,
+    ur_sampler_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urSamplerRetain
-typedef ur_result_t(UR_APICALL *ur_pfnSamplerRetain_t)(
-    ur_sampler_handle_t);
+/// @brief Function-pointer for urSamplerRetain 
+typedef ur_result_t (UR_APICALL *ur_pfnSamplerRetain_t)(
+    ur_sampler_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urSamplerRelease
-typedef ur_result_t(UR_APICALL *ur_pfnSamplerRelease_t)(
-    ur_sampler_handle_t);
+/// @brief Function-pointer for urSamplerRelease 
+typedef ur_result_t (UR_APICALL *ur_pfnSamplerRelease_t)(
+    ur_sampler_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urSamplerGetInfo
-typedef ur_result_t(UR_APICALL *ur_pfnSamplerGetInfo_t)(
+/// @brief Function-pointer for urSamplerGetInfo 
+typedef ur_result_t (UR_APICALL *ur_pfnSamplerGetInfo_t)(
     ur_sampler_handle_t,
     ur_sampler_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urSamplerGetNativeHandle
-typedef ur_result_t(UR_APICALL *ur_pfnSamplerGetNativeHandle_t)(
+/// @brief Function-pointer for urSamplerGetNativeHandle 
+typedef ur_result_t (UR_APICALL *ur_pfnSamplerGetNativeHandle_t)(
     ur_sampler_handle_t,
-    ur_native_handle_t *);
+    ur_native_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urSamplerCreateWithNativeHandle
-typedef ur_result_t(UR_APICALL *ur_pfnSamplerCreateWithNativeHandle_t)(
+/// @brief Function-pointer for urSamplerCreateWithNativeHandle 
+typedef ur_result_t (UR_APICALL *ur_pfnSamplerCreateWithNativeHandle_t)(
     ur_native_handle_t,
     ur_context_handle_t,
-    const ur_sampler_native_properties_t *,
-    ur_sampler_handle_t *);
+    const ur_sampler_native_properties_t*,
+    ur_sampler_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of Sampler functions pointers
-typedef struct ur_sampler_dditable_t {
-    ur_pfnSamplerCreate_t pfnCreate;
-    ur_pfnSamplerRetain_t pfnRetain;
-    ur_pfnSamplerRelease_t pfnRelease;
-    ur_pfnSamplerGetInfo_t pfnGetInfo;
-    ur_pfnSamplerGetNativeHandle_t pfnGetNativeHandle;
-    ur_pfnSamplerCreateWithNativeHandle_t pfnCreateWithNativeHandle;
+typedef struct ur_sampler_dditable_t
+{
+    ur_pfnSamplerCreate_t                                       pfnCreate;
+    ur_pfnSamplerRetain_t                                       pfnRetain;
+    ur_pfnSamplerRelease_t                                      pfnRelease;
+    ur_pfnSamplerGetInfo_t                                      pfnGetInfo;
+    ur_pfnSamplerGetNativeHandle_t                              pfnGetNativeHandle;
+    ur_pfnSamplerCreateWithNativeHandle_t                       pfnCreateWithNativeHandle;
 } ur_sampler_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -830,110 +916,122 @@ typedef struct ur_sampler_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetSamplerProcAddrTable(
-    ur_api_version_t version,        ///< [in] API version requested
-    ur_sampler_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_sampler_dditable_t* pDdiTable                ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetSamplerProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetSamplerProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetSamplerProcAddrTable_t)(
     ur_api_version_t,
-    ur_sampler_dditable_t *);
+    ur_sampler_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urMemImageCreate
-typedef ur_result_t(UR_APICALL *ur_pfnMemImageCreate_t)(
+/// @brief Function-pointer for urMemImageCreate 
+typedef ur_result_t (UR_APICALL *ur_pfnMemImageCreate_t)(
     ur_context_handle_t,
     ur_mem_flags_t,
-    const ur_image_format_t *,
-    const ur_image_desc_t *,
-    void *,
-    ur_mem_handle_t *);
+    const ur_image_format_t*,
+    const ur_image_desc_t*,
+    void*,
+    ur_mem_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urMemBufferCreate
-typedef ur_result_t(UR_APICALL *ur_pfnMemBufferCreate_t)(
+/// @brief Function-pointer for urMemBufferCreate 
+typedef ur_result_t (UR_APICALL *ur_pfnMemBufferCreate_t)(
     ur_context_handle_t,
     ur_mem_flags_t,
     size_t,
-    const ur_buffer_properties_t *,
-    ur_mem_handle_t *);
+    const ur_buffer_properties_t*,
+    ur_mem_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urMemRetain
-typedef ur_result_t(UR_APICALL *ur_pfnMemRetain_t)(
-    ur_mem_handle_t);
+/// @brief Function-pointer for urMemRetain 
+typedef ur_result_t (UR_APICALL *ur_pfnMemRetain_t)(
+    ur_mem_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urMemRelease
-typedef ur_result_t(UR_APICALL *ur_pfnMemRelease_t)(
-    ur_mem_handle_t);
+/// @brief Function-pointer for urMemRelease 
+typedef ur_result_t (UR_APICALL *ur_pfnMemRelease_t)(
+    ur_mem_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urMemBufferPartition
-typedef ur_result_t(UR_APICALL *ur_pfnMemBufferPartition_t)(
+/// @brief Function-pointer for urMemBufferPartition 
+typedef ur_result_t (UR_APICALL *ur_pfnMemBufferPartition_t)(
     ur_mem_handle_t,
     ur_mem_flags_t,
     ur_buffer_create_type_t,
-    const ur_buffer_region_t *,
-    ur_mem_handle_t *);
+    const ur_buffer_region_t*,
+    ur_mem_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urMemGetNativeHandle
-typedef ur_result_t(UR_APICALL *ur_pfnMemGetNativeHandle_t)(
+/// @brief Function-pointer for urMemGetNativeHandle 
+typedef ur_result_t (UR_APICALL *ur_pfnMemGetNativeHandle_t)(
     ur_mem_handle_t,
     ur_device_handle_t,
-    ur_native_handle_t *);
+    ur_native_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urMemBufferCreateWithNativeHandle
-typedef ur_result_t(UR_APICALL *ur_pfnMemBufferCreateWithNativeHandle_t)(
+/// @brief Function-pointer for urMemBufferCreateWithNativeHandle 
+typedef ur_result_t (UR_APICALL *ur_pfnMemBufferCreateWithNativeHandle_t)(
     ur_native_handle_t,
     ur_context_handle_t,
-    const ur_mem_native_properties_t *,
-    ur_mem_handle_t *);
+    const ur_mem_native_properties_t*,
+    ur_mem_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urMemImageCreateWithNativeHandle
-typedef ur_result_t(UR_APICALL *ur_pfnMemImageCreateWithNativeHandle_t)(
+/// @brief Function-pointer for urMemImageCreateWithNativeHandle 
+typedef ur_result_t (UR_APICALL *ur_pfnMemImageCreateWithNativeHandle_t)(
     ur_native_handle_t,
     ur_context_handle_t,
-    const ur_image_format_t *,
-    const ur_image_desc_t *,
-    const ur_mem_native_properties_t *,
-    ur_mem_handle_t *);
+    const ur_image_format_t*,
+    const ur_image_desc_t*,
+    const ur_mem_native_properties_t*,
+    ur_mem_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urMemGetInfo
-typedef ur_result_t(UR_APICALL *ur_pfnMemGetInfo_t)(
+/// @brief Function-pointer for urMemGetInfo 
+typedef ur_result_t (UR_APICALL *ur_pfnMemGetInfo_t)(
     ur_mem_handle_t,
     ur_mem_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urMemImageGetInfo
-typedef ur_result_t(UR_APICALL *ur_pfnMemImageGetInfo_t)(
+/// @brief Function-pointer for urMemImageGetInfo 
+typedef ur_result_t (UR_APICALL *ur_pfnMemImageGetInfo_t)(
     ur_mem_handle_t,
     ur_image_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of Mem functions pointers
-typedef struct ur_mem_dditable_t {
-    ur_pfnMemImageCreate_t pfnImageCreate;
-    ur_pfnMemBufferCreate_t pfnBufferCreate;
-    ur_pfnMemRetain_t pfnRetain;
-    ur_pfnMemRelease_t pfnRelease;
-    ur_pfnMemBufferPartition_t pfnBufferPartition;
-    ur_pfnMemGetNativeHandle_t pfnGetNativeHandle;
-    ur_pfnMemBufferCreateWithNativeHandle_t pfnBufferCreateWithNativeHandle;
-    ur_pfnMemImageCreateWithNativeHandle_t pfnImageCreateWithNativeHandle;
-    ur_pfnMemGetInfo_t pfnGetInfo;
-    ur_pfnMemImageGetInfo_t pfnImageGetInfo;
+typedef struct ur_mem_dditable_t
+{
+    ur_pfnMemImageCreate_t                                      pfnImageCreate;
+    ur_pfnMemBufferCreate_t                                     pfnBufferCreate;
+    ur_pfnMemRetain_t                                           pfnRetain;
+    ur_pfnMemRelease_t                                          pfnRelease;
+    ur_pfnMemBufferPartition_t                                  pfnBufferPartition;
+    ur_pfnMemGetNativeHandle_t                                  pfnGetNativeHandle;
+    ur_pfnMemBufferCreateWithNativeHandle_t                     pfnBufferCreateWithNativeHandle;
+    ur_pfnMemImageCreateWithNativeHandle_t                      pfnImageCreateWithNativeHandle;
+    ur_pfnMemGetInfo_t                                          pfnGetInfo;
+    ur_pfnMemImageGetInfo_t                                     pfnImageGetInfo;
 } ur_mem_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -947,41 +1045,46 @@ typedef struct ur_mem_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetMemProcAddrTable(
-    ur_api_version_t version,    ///< [in] API version requested
-    ur_mem_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_mem_dditable_t* pDdiTable                    ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetMemProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetMemProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetMemProcAddrTable_t)(
     ur_api_version_t,
-    ur_mem_dditable_t *);
+    ur_mem_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urPhysicalMemCreate
-typedef ur_result_t(UR_APICALL *ur_pfnPhysicalMemCreate_t)(
+/// @brief Function-pointer for urPhysicalMemCreate 
+typedef ur_result_t (UR_APICALL *ur_pfnPhysicalMemCreate_t)(
     ur_context_handle_t,
     ur_device_handle_t,
     size_t,
-    const ur_physical_mem_properties_t *,
-    ur_physical_mem_handle_t *);
+    const ur_physical_mem_properties_t*,
+    ur_physical_mem_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urPhysicalMemRetain
-typedef ur_result_t(UR_APICALL *ur_pfnPhysicalMemRetain_t)(
-    ur_physical_mem_handle_t);
+/// @brief Function-pointer for urPhysicalMemRetain 
+typedef ur_result_t (UR_APICALL *ur_pfnPhysicalMemRetain_t)(
+    ur_physical_mem_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urPhysicalMemRelease
-typedef ur_result_t(UR_APICALL *ur_pfnPhysicalMemRelease_t)(
-    ur_physical_mem_handle_t);
+/// @brief Function-pointer for urPhysicalMemRelease 
+typedef ur_result_t (UR_APICALL *ur_pfnPhysicalMemRelease_t)(
+    ur_physical_mem_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of PhysicalMem functions pointers
-typedef struct ur_physical_mem_dditable_t {
-    ur_pfnPhysicalMemCreate_t pfnCreate;
-    ur_pfnPhysicalMemRetain_t pfnRetain;
-    ur_pfnPhysicalMemRelease_t pfnRelease;
+typedef struct ur_physical_mem_dditable_t
+{
+    ur_pfnPhysicalMemCreate_t                                   pfnCreate;
+    ur_pfnPhysicalMemRetain_t                                   pfnRetain;
+    ur_pfnPhysicalMemRelease_t                                  pfnRelease;
 } ur_physical_mem_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -995,57 +1098,64 @@ typedef struct ur_physical_mem_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetPhysicalMemProcAddrTable(
-    ur_api_version_t version,             ///< [in] API version requested
-    ur_physical_mem_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_physical_mem_dditable_t* pDdiTable           ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetPhysicalMemProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetPhysicalMemProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetPhysicalMemProcAddrTable_t)(
     ur_api_version_t,
-    ur_physical_mem_dditable_t *);
+    ur_physical_mem_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urAdapterGet
-typedef ur_result_t(UR_APICALL *ur_pfnAdapterGet_t)(
+/// @brief Function-pointer for urAdapterGet 
+typedef ur_result_t (UR_APICALL *ur_pfnAdapterGet_t)(
     uint32_t,
-    ur_adapter_handle_t *,
-    uint32_t *);
+    ur_adapter_handle_t*,
+    uint32_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urAdapterRelease
-typedef ur_result_t(UR_APICALL *ur_pfnAdapterRelease_t)(
-    ur_adapter_handle_t);
+/// @brief Function-pointer for urAdapterRelease 
+typedef ur_result_t (UR_APICALL *ur_pfnAdapterRelease_t)(
+    ur_adapter_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urAdapterRetain
-typedef ur_result_t(UR_APICALL *ur_pfnAdapterRetain_t)(
-    ur_adapter_handle_t);
+/// @brief Function-pointer for urAdapterRetain 
+typedef ur_result_t (UR_APICALL *ur_pfnAdapterRetain_t)(
+    ur_adapter_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urAdapterGetLastError
-typedef ur_result_t(UR_APICALL *ur_pfnAdapterGetLastError_t)(
+/// @brief Function-pointer for urAdapterGetLastError 
+typedef ur_result_t (UR_APICALL *ur_pfnAdapterGetLastError_t)(
     ur_adapter_handle_t,
-    const char **,
-    int32_t *);
+    const char**,
+    int32_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urAdapterGetInfo
-typedef ur_result_t(UR_APICALL *ur_pfnAdapterGetInfo_t)(
+/// @brief Function-pointer for urAdapterGetInfo 
+typedef ur_result_t (UR_APICALL *ur_pfnAdapterGetInfo_t)(
     ur_adapter_handle_t,
     ur_adapter_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of Global functions pointers
-typedef struct ur_global_dditable_t {
-    ur_pfnAdapterGet_t pfnAdapterGet;
-    ur_pfnAdapterRelease_t pfnAdapterRelease;
-    ur_pfnAdapterRetain_t pfnAdapterRetain;
-    ur_pfnAdapterGetLastError_t pfnAdapterGetLastError;
-    ur_pfnAdapterGetInfo_t pfnAdapterGetInfo;
+typedef struct ur_global_dditable_t
+{
+    ur_pfnAdapterGet_t                                          pfnAdapterGet;
+    ur_pfnAdapterRelease_t                                      pfnAdapterRelease;
+    ur_pfnAdapterRetain_t                                       pfnAdapterRetain;
+    ur_pfnAdapterGetLastError_t                                 pfnAdapterGetLastError;
+    ur_pfnAdapterGetInfo_t                                      pfnAdapterGetInfo;
 } ur_global_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1059,74 +1169,80 @@ typedef struct ur_global_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetGlobalProcAddrTable(
-    ur_api_version_t version,       ///< [in] API version requested
-    ur_global_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_global_dditable_t* pDdiTable                 ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetGlobalProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetGlobalProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetGlobalProcAddrTable_t)(
     ur_api_version_t,
-    ur_global_dditable_t *);
+    ur_global_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueKernelLaunch
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueKernelLaunch_t)(
+/// @brief Function-pointer for urEnqueueKernelLaunch 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueKernelLaunch_t)(
     ur_queue_handle_t,
     ur_kernel_handle_t,
     uint32_t,
-    const size_t *,
-    const size_t *,
-    const size_t *,
+    const size_t*,
+    const size_t*,
+    const size_t*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueEventsWait
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueEventsWait_t)(
+/// @brief Function-pointer for urEnqueueEventsWait 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueEventsWait_t)(
     ur_queue_handle_t,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueEventsWaitWithBarrier
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueEventsWaitWithBarrier_t)(
+/// @brief Function-pointer for urEnqueueEventsWaitWithBarrier 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueEventsWaitWithBarrier_t)(
     ur_queue_handle_t,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueMemBufferRead
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueMemBufferRead_t)(
+/// @brief Function-pointer for urEnqueueMemBufferRead 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueMemBufferRead_t)(
     ur_queue_handle_t,
     ur_mem_handle_t,
     bool,
     size_t,
     size_t,
-    void *,
+    void*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueMemBufferWrite
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueMemBufferWrite_t)(
+/// @brief Function-pointer for urEnqueueMemBufferWrite 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueMemBufferWrite_t)(
     ur_queue_handle_t,
     ur_mem_handle_t,
     bool,
     size_t,
     size_t,
-    const void *,
+    const void*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueMemBufferReadRect
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueMemBufferReadRect_t)(
+/// @brief Function-pointer for urEnqueueMemBufferReadRect 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueMemBufferReadRect_t)(
     ur_queue_handle_t,
     ur_mem_handle_t,
     bool,
@@ -1137,14 +1253,15 @@ typedef ur_result_t(UR_APICALL *ur_pfnEnqueueMemBufferReadRect_t)(
     size_t,
     size_t,
     size_t,
-    void *,
+    void*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueMemBufferWriteRect
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueMemBufferWriteRect_t)(
+/// @brief Function-pointer for urEnqueueMemBufferWriteRect 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueMemBufferWriteRect_t)(
     ur_queue_handle_t,
     ur_mem_handle_t,
     bool,
@@ -1155,14 +1272,15 @@ typedef ur_result_t(UR_APICALL *ur_pfnEnqueueMemBufferWriteRect_t)(
     size_t,
     size_t,
     size_t,
-    void *,
+    void*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueMemBufferCopy
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueMemBufferCopy_t)(
+/// @brief Function-pointer for urEnqueueMemBufferCopy 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueMemBufferCopy_t)(
     ur_queue_handle_t,
     ur_mem_handle_t,
     ur_mem_handle_t,
@@ -1170,12 +1288,13 @@ typedef ur_result_t(UR_APICALL *ur_pfnEnqueueMemBufferCopy_t)(
     size_t,
     size_t,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueMemBufferCopyRect
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueMemBufferCopyRect_t)(
+/// @brief Function-pointer for urEnqueueMemBufferCopyRect 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueMemBufferCopyRect_t)(
     ur_queue_handle_t,
     ur_mem_handle_t,
     ur_mem_handle_t,
@@ -1187,25 +1306,27 @@ typedef ur_result_t(UR_APICALL *ur_pfnEnqueueMemBufferCopyRect_t)(
     size_t,
     size_t,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueMemBufferFill
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueMemBufferFill_t)(
+/// @brief Function-pointer for urEnqueueMemBufferFill 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueMemBufferFill_t)(
     ur_queue_handle_t,
     ur_mem_handle_t,
-    const void *,
+    const void*,
     size_t,
     size_t,
     size_t,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueMemImageRead
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueMemImageRead_t)(
+/// @brief Function-pointer for urEnqueueMemImageRead 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueMemImageRead_t)(
     ur_queue_handle_t,
     ur_mem_handle_t,
     bool,
@@ -1213,14 +1334,15 @@ typedef ur_result_t(UR_APICALL *ur_pfnEnqueueMemImageRead_t)(
     ur_rect_region_t,
     size_t,
     size_t,
-    void *,
+    void*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueMemImageWrite
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueMemImageWrite_t)(
+/// @brief Function-pointer for urEnqueueMemImageWrite 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueMemImageWrite_t)(
     ur_queue_handle_t,
     ur_mem_handle_t,
     bool,
@@ -1228,14 +1350,15 @@ typedef ur_result_t(UR_APICALL *ur_pfnEnqueueMemImageWrite_t)(
     ur_rect_region_t,
     size_t,
     size_t,
-    void *,
+    void*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueMemImageCopy
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueMemImageCopy_t)(
+/// @brief Function-pointer for urEnqueueMemImageCopy 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueMemImageCopy_t)(
     ur_queue_handle_t,
     ur_mem_handle_t,
     ur_mem_handle_t,
@@ -1243,12 +1366,13 @@ typedef ur_result_t(UR_APICALL *ur_pfnEnqueueMemImageCopy_t)(
     ur_rect_offset_t,
     ur_rect_region_t,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueMemBufferMap
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueMemBufferMap_t)(
+/// @brief Function-pointer for urEnqueueMemBufferMap 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueMemBufferMap_t)(
     ur_queue_handle_t,
     ur_mem_handle_t,
     bool,
@@ -1256,175 +1380,188 @@ typedef ur_result_t(UR_APICALL *ur_pfnEnqueueMemBufferMap_t)(
     size_t,
     size_t,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *,
-    void **);
+    const ur_event_handle_t*,
+    ur_event_handle_t*,
+    void**
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueMemUnmap
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueMemUnmap_t)(
+/// @brief Function-pointer for urEnqueueMemUnmap 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueMemUnmap_t)(
     ur_queue_handle_t,
     ur_mem_handle_t,
-    void *,
+    void*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueUSMFill
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueUSMFill_t)(
+/// @brief Function-pointer for urEnqueueUSMFill 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueUSMFill_t)(
     ur_queue_handle_t,
-    void *,
+    void*,
     size_t,
-    const void *,
+    const void*,
     size_t,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueUSMMemcpy
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueUSMMemcpy_t)(
+/// @brief Function-pointer for urEnqueueUSMMemcpy 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueUSMMemcpy_t)(
     ur_queue_handle_t,
     bool,
-    void *,
-    const void *,
+    void*,
+    const void*,
     size_t,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueUSMPrefetch
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueUSMPrefetch_t)(
+/// @brief Function-pointer for urEnqueueUSMPrefetch 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueUSMPrefetch_t)(
     ur_queue_handle_t,
-    const void *,
+    const void*,
     size_t,
     ur_usm_migration_flags_t,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueUSMAdvise
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueUSMAdvise_t)(
+/// @brief Function-pointer for urEnqueueUSMAdvise 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueUSMAdvise_t)(
     ur_queue_handle_t,
-    const void *,
+    const void*,
     size_t,
     ur_usm_advice_flags_t,
-    ur_event_handle_t *);
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueUSMFill2D
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueUSMFill2D_t)(
+/// @brief Function-pointer for urEnqueueUSMFill2D 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueUSMFill2D_t)(
     ur_queue_handle_t,
-    void *,
+    void*,
     size_t,
     size_t,
-    const void *,
+    const void*,
     size_t,
     size_t,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueUSMMemcpy2D
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueUSMMemcpy2D_t)(
+/// @brief Function-pointer for urEnqueueUSMMemcpy2D 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueUSMMemcpy2D_t)(
     ur_queue_handle_t,
     bool,
-    void *,
+    void*,
     size_t,
-    const void *,
+    const void*,
     size_t,
     size_t,
     size_t,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueDeviceGlobalVariableWrite
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueDeviceGlobalVariableWrite_t)(
+/// @brief Function-pointer for urEnqueueDeviceGlobalVariableWrite 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueDeviceGlobalVariableWrite_t)(
     ur_queue_handle_t,
     ur_program_handle_t,
-    const char *,
+    const char*,
     bool,
     size_t,
     size_t,
-    const void *,
+    const void*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueDeviceGlobalVariableRead
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueDeviceGlobalVariableRead_t)(
+/// @brief Function-pointer for urEnqueueDeviceGlobalVariableRead 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueDeviceGlobalVariableRead_t)(
     ur_queue_handle_t,
     ur_program_handle_t,
-    const char *,
+    const char*,
     bool,
     size_t,
     size_t,
-    void *,
+    void*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueReadHostPipe
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueReadHostPipe_t)(
+/// @brief Function-pointer for urEnqueueReadHostPipe 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueReadHostPipe_t)(
     ur_queue_handle_t,
     ur_program_handle_t,
-    const char *,
+    const char*,
     bool,
-    void *,
+    void*,
     size_t,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueWriteHostPipe
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueWriteHostPipe_t)(
+/// @brief Function-pointer for urEnqueueWriteHostPipe 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueWriteHostPipe_t)(
     ur_queue_handle_t,
     ur_program_handle_t,
-    const char *,
+    const char*,
     bool,
-    void *,
+    void*,
     size_t,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of Enqueue functions pointers
-typedef struct ur_enqueue_dditable_t {
-    ur_pfnEnqueueKernelLaunch_t pfnKernelLaunch;
-    ur_pfnEnqueueEventsWait_t pfnEventsWait;
-    ur_pfnEnqueueEventsWaitWithBarrier_t pfnEventsWaitWithBarrier;
-    ur_pfnEnqueueMemBufferRead_t pfnMemBufferRead;
-    ur_pfnEnqueueMemBufferWrite_t pfnMemBufferWrite;
-    ur_pfnEnqueueMemBufferReadRect_t pfnMemBufferReadRect;
-    ur_pfnEnqueueMemBufferWriteRect_t pfnMemBufferWriteRect;
-    ur_pfnEnqueueMemBufferCopy_t pfnMemBufferCopy;
-    ur_pfnEnqueueMemBufferCopyRect_t pfnMemBufferCopyRect;
-    ur_pfnEnqueueMemBufferFill_t pfnMemBufferFill;
-    ur_pfnEnqueueMemImageRead_t pfnMemImageRead;
-    ur_pfnEnqueueMemImageWrite_t pfnMemImageWrite;
-    ur_pfnEnqueueMemImageCopy_t pfnMemImageCopy;
-    ur_pfnEnqueueMemBufferMap_t pfnMemBufferMap;
-    ur_pfnEnqueueMemUnmap_t pfnMemUnmap;
-    ur_pfnEnqueueUSMFill_t pfnUSMFill;
-    ur_pfnEnqueueUSMMemcpy_t pfnUSMMemcpy;
-    ur_pfnEnqueueUSMPrefetch_t pfnUSMPrefetch;
-    ur_pfnEnqueueUSMAdvise_t pfnUSMAdvise;
-    ur_pfnEnqueueUSMFill2D_t pfnUSMFill2D;
-    ur_pfnEnqueueUSMMemcpy2D_t pfnUSMMemcpy2D;
-    ur_pfnEnqueueDeviceGlobalVariableWrite_t pfnDeviceGlobalVariableWrite;
-    ur_pfnEnqueueDeviceGlobalVariableRead_t pfnDeviceGlobalVariableRead;
-    ur_pfnEnqueueReadHostPipe_t pfnReadHostPipe;
-    ur_pfnEnqueueWriteHostPipe_t pfnWriteHostPipe;
+typedef struct ur_enqueue_dditable_t
+{
+    ur_pfnEnqueueKernelLaunch_t                                 pfnKernelLaunch;
+    ur_pfnEnqueueEventsWait_t                                   pfnEventsWait;
+    ur_pfnEnqueueEventsWaitWithBarrier_t                        pfnEventsWaitWithBarrier;
+    ur_pfnEnqueueMemBufferRead_t                                pfnMemBufferRead;
+    ur_pfnEnqueueMemBufferWrite_t                               pfnMemBufferWrite;
+    ur_pfnEnqueueMemBufferReadRect_t                            pfnMemBufferReadRect;
+    ur_pfnEnqueueMemBufferWriteRect_t                           pfnMemBufferWriteRect;
+    ur_pfnEnqueueMemBufferCopy_t                                pfnMemBufferCopy;
+    ur_pfnEnqueueMemBufferCopyRect_t                            pfnMemBufferCopyRect;
+    ur_pfnEnqueueMemBufferFill_t                                pfnMemBufferFill;
+    ur_pfnEnqueueMemImageRead_t                                 pfnMemImageRead;
+    ur_pfnEnqueueMemImageWrite_t                                pfnMemImageWrite;
+    ur_pfnEnqueueMemImageCopy_t                                 pfnMemImageCopy;
+    ur_pfnEnqueueMemBufferMap_t                                 pfnMemBufferMap;
+    ur_pfnEnqueueMemUnmap_t                                     pfnMemUnmap;
+    ur_pfnEnqueueUSMFill_t                                      pfnUSMFill;
+    ur_pfnEnqueueUSMMemcpy_t                                    pfnUSMMemcpy;
+    ur_pfnEnqueueUSMPrefetch_t                                  pfnUSMPrefetch;
+    ur_pfnEnqueueUSMAdvise_t                                    pfnUSMAdvise;
+    ur_pfnEnqueueUSMFill2D_t                                    pfnUSMFill2D;
+    ur_pfnEnqueueUSMMemcpy2D_t                                  pfnUSMMemcpy2D;
+    ur_pfnEnqueueDeviceGlobalVariableWrite_t                    pfnDeviceGlobalVariableWrite;
+    ur_pfnEnqueueDeviceGlobalVariableRead_t                     pfnDeviceGlobalVariableRead;
+    ur_pfnEnqueueReadHostPipe_t                                 pfnReadHostPipe;
+    ur_pfnEnqueueWriteHostPipe_t                                pfnWriteHostPipe;
 } ur_enqueue_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1438,72 +1575,78 @@ typedef struct ur_enqueue_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetEnqueueProcAddrTable(
-    ur_api_version_t version,        ///< [in] API version requested
-    ur_enqueue_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_enqueue_dditable_t* pDdiTable                ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetEnqueueProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetEnqueueProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetEnqueueProcAddrTable_t)(
     ur_api_version_t,
-    ur_enqueue_dditable_t *);
+    ur_enqueue_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueKernelLaunchCustomExp
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueKernelLaunchCustomExp_t)(
+/// @brief Function-pointer for urEnqueueKernelLaunchCustomExp 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueKernelLaunchCustomExp_t)(
     ur_queue_handle_t,
     ur_kernel_handle_t,
     uint32_t,
-    const size_t *,
-    const size_t *,
+    const size_t*,
+    const size_t*,
     uint32_t,
-    const ur_exp_launch_property_t *,
+    const ur_exp_launch_property_t*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueCooperativeKernelLaunchExp
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueCooperativeKernelLaunchExp_t)(
+/// @brief Function-pointer for urEnqueueCooperativeKernelLaunchExp 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueCooperativeKernelLaunchExp_t)(
     ur_queue_handle_t,
     ur_kernel_handle_t,
     uint32_t,
-    const size_t *,
-    const size_t *,
-    const size_t *,
+    const size_t*,
+    const size_t*,
+    const size_t*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueTimestampRecordingExp
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueTimestampRecordingExp_t)(
+/// @brief Function-pointer for urEnqueueTimestampRecordingExp 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueTimestampRecordingExp_t)(
     ur_queue_handle_t,
     bool,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urEnqueueNativeCommandExp
-typedef ur_result_t(UR_APICALL *ur_pfnEnqueueNativeCommandExp_t)(
+/// @brief Function-pointer for urEnqueueNativeCommandExp 
+typedef ur_result_t (UR_APICALL *ur_pfnEnqueueNativeCommandExp_t)(
     ur_queue_handle_t,
     ur_exp_enqueue_native_command_function_t,
-    void *,
+    void*,
     uint32_t,
-    const ur_mem_handle_t *,
-    const ur_exp_enqueue_native_command_properties_t *,
+    const ur_mem_handle_t*,
+    const ur_exp_enqueue_native_command_properties_t*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of EnqueueExp functions pointers
-typedef struct ur_enqueue_exp_dditable_t {
-    ur_pfnEnqueueKernelLaunchCustomExp_t pfnKernelLaunchCustomExp;
-    ur_pfnEnqueueCooperativeKernelLaunchExp_t pfnCooperativeKernelLaunchExp;
-    ur_pfnEnqueueTimestampRecordingExp_t pfnTimestampRecordingExp;
-    ur_pfnEnqueueNativeCommandExp_t pfnNativeCommandExp;
+typedef struct ur_enqueue_exp_dditable_t
+{
+    ur_pfnEnqueueKernelLaunchCustomExp_t                        pfnKernelLaunchCustomExp;
+    ur_pfnEnqueueCooperativeKernelLaunchExp_t                   pfnCooperativeKernelLaunchExp;
+    ur_pfnEnqueueTimestampRecordingExp_t                        pfnTimestampRecordingExp;
+    ur_pfnEnqueueNativeCommandExp_t                             pfnNativeCommandExp;
 } ur_enqueue_exp_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1517,204 +1660,224 @@ typedef struct ur_enqueue_exp_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetEnqueueExpProcAddrTable(
-    ur_api_version_t version,            ///< [in] API version requested
-    ur_enqueue_exp_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_enqueue_exp_dditable_t* pDdiTable            ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetEnqueueExpProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetEnqueueExpProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetEnqueueExpProcAddrTable_t)(
     ur_api_version_t,
-    ur_enqueue_exp_dditable_t *);
+    ur_enqueue_exp_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urBindlessImagesUnsampledImageHandleDestroyExp
-typedef ur_result_t(UR_APICALL *ur_pfnBindlessImagesUnsampledImageHandleDestroyExp_t)(
+/// @brief Function-pointer for urBindlessImagesUnsampledImageHandleDestroyExp 
+typedef ur_result_t (UR_APICALL *ur_pfnBindlessImagesUnsampledImageHandleDestroyExp_t)(
     ur_context_handle_t,
     ur_device_handle_t,
-    ur_exp_image_native_handle_t);
+    ur_exp_image_native_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urBindlessImagesSampledImageHandleDestroyExp
-typedef ur_result_t(UR_APICALL *ur_pfnBindlessImagesSampledImageHandleDestroyExp_t)(
+/// @brief Function-pointer for urBindlessImagesSampledImageHandleDestroyExp 
+typedef ur_result_t (UR_APICALL *ur_pfnBindlessImagesSampledImageHandleDestroyExp_t)(
     ur_context_handle_t,
     ur_device_handle_t,
-    ur_exp_image_native_handle_t);
+    ur_exp_image_native_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urBindlessImagesImageAllocateExp
-typedef ur_result_t(UR_APICALL *ur_pfnBindlessImagesImageAllocateExp_t)(
+/// @brief Function-pointer for urBindlessImagesImageAllocateExp 
+typedef ur_result_t (UR_APICALL *ur_pfnBindlessImagesImageAllocateExp_t)(
     ur_context_handle_t,
     ur_device_handle_t,
-    const ur_image_format_t *,
-    const ur_image_desc_t *,
-    ur_exp_image_mem_native_handle_t *);
+    const ur_image_format_t*,
+    const ur_image_desc_t*,
+    ur_exp_image_mem_native_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urBindlessImagesImageFreeExp
-typedef ur_result_t(UR_APICALL *ur_pfnBindlessImagesImageFreeExp_t)(
+/// @brief Function-pointer for urBindlessImagesImageFreeExp 
+typedef ur_result_t (UR_APICALL *ur_pfnBindlessImagesImageFreeExp_t)(
     ur_context_handle_t,
     ur_device_handle_t,
-    ur_exp_image_mem_native_handle_t);
+    ur_exp_image_mem_native_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urBindlessImagesUnsampledImageCreateExp
-typedef ur_result_t(UR_APICALL *ur_pfnBindlessImagesUnsampledImageCreateExp_t)(
+/// @brief Function-pointer for urBindlessImagesUnsampledImageCreateExp 
+typedef ur_result_t (UR_APICALL *ur_pfnBindlessImagesUnsampledImageCreateExp_t)(
     ur_context_handle_t,
     ur_device_handle_t,
     ur_exp_image_mem_native_handle_t,
-    const ur_image_format_t *,
-    const ur_image_desc_t *,
-    ur_exp_image_native_handle_t *);
+    const ur_image_format_t*,
+    const ur_image_desc_t*,
+    ur_exp_image_native_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urBindlessImagesSampledImageCreateExp
-typedef ur_result_t(UR_APICALL *ur_pfnBindlessImagesSampledImageCreateExp_t)(
+/// @brief Function-pointer for urBindlessImagesSampledImageCreateExp 
+typedef ur_result_t (UR_APICALL *ur_pfnBindlessImagesSampledImageCreateExp_t)(
     ur_context_handle_t,
     ur_device_handle_t,
     ur_exp_image_mem_native_handle_t,
-    const ur_image_format_t *,
-    const ur_image_desc_t *,
+    const ur_image_format_t*,
+    const ur_image_desc_t*,
     ur_sampler_handle_t,
-    ur_exp_image_native_handle_t *);
+    ur_exp_image_native_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urBindlessImagesImageCopyExp
-typedef ur_result_t(UR_APICALL *ur_pfnBindlessImagesImageCopyExp_t)(
+/// @brief Function-pointer for urBindlessImagesImageCopyExp 
+typedef ur_result_t (UR_APICALL *ur_pfnBindlessImagesImageCopyExp_t)(
     ur_queue_handle_t,
-    const void *,
-    void *,
-    const ur_image_desc_t *,
-    const ur_image_desc_t *,
-    const ur_image_format_t *,
-    const ur_image_format_t *,
-    ur_exp_image_copy_region_t *,
+    const void*,
+    void*,
+    const ur_image_desc_t*,
+    const ur_image_desc_t*,
+    const ur_image_format_t*,
+    const ur_image_format_t*,
+    ur_exp_image_copy_region_t*,
     ur_exp_image_copy_flags_t,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urBindlessImagesImageGetInfoExp
-typedef ur_result_t(UR_APICALL *ur_pfnBindlessImagesImageGetInfoExp_t)(
+/// @brief Function-pointer for urBindlessImagesImageGetInfoExp 
+typedef ur_result_t (UR_APICALL *ur_pfnBindlessImagesImageGetInfoExp_t)(
     ur_context_handle_t,
     ur_exp_image_mem_native_handle_t,
     ur_image_info_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urBindlessImagesMipmapGetLevelExp
-typedef ur_result_t(UR_APICALL *ur_pfnBindlessImagesMipmapGetLevelExp_t)(
+/// @brief Function-pointer for urBindlessImagesMipmapGetLevelExp 
+typedef ur_result_t (UR_APICALL *ur_pfnBindlessImagesMipmapGetLevelExp_t)(
     ur_context_handle_t,
     ur_device_handle_t,
     ur_exp_image_mem_native_handle_t,
     uint32_t,
-    ur_exp_image_mem_native_handle_t *);
+    ur_exp_image_mem_native_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urBindlessImagesMipmapFreeExp
-typedef ur_result_t(UR_APICALL *ur_pfnBindlessImagesMipmapFreeExp_t)(
+/// @brief Function-pointer for urBindlessImagesMipmapFreeExp 
+typedef ur_result_t (UR_APICALL *ur_pfnBindlessImagesMipmapFreeExp_t)(
     ur_context_handle_t,
     ur_device_handle_t,
-    ur_exp_image_mem_native_handle_t);
+    ur_exp_image_mem_native_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urBindlessImagesImportExternalMemoryExp
-typedef ur_result_t(UR_APICALL *ur_pfnBindlessImagesImportExternalMemoryExp_t)(
+/// @brief Function-pointer for urBindlessImagesImportExternalMemoryExp 
+typedef ur_result_t (UR_APICALL *ur_pfnBindlessImagesImportExternalMemoryExp_t)(
     ur_context_handle_t,
     ur_device_handle_t,
     size_t,
     ur_exp_external_mem_type_t,
-    ur_exp_external_mem_desc_t *,
-    ur_exp_external_mem_handle_t *);
+    ur_exp_external_mem_desc_t*,
+    ur_exp_external_mem_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urBindlessImagesMapExternalArrayExp
-typedef ur_result_t(UR_APICALL *ur_pfnBindlessImagesMapExternalArrayExp_t)(
+/// @brief Function-pointer for urBindlessImagesMapExternalArrayExp 
+typedef ur_result_t (UR_APICALL *ur_pfnBindlessImagesMapExternalArrayExp_t)(
     ur_context_handle_t,
     ur_device_handle_t,
-    const ur_image_format_t *,
-    const ur_image_desc_t *,
+    const ur_image_format_t*,
+    const ur_image_desc_t*,
     ur_exp_external_mem_handle_t,
-    ur_exp_image_mem_native_handle_t *);
+    ur_exp_image_mem_native_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urBindlessImagesMapExternalLinearMemoryExp
-typedef ur_result_t(UR_APICALL *ur_pfnBindlessImagesMapExternalLinearMemoryExp_t)(
+/// @brief Function-pointer for urBindlessImagesMapExternalLinearMemoryExp 
+typedef ur_result_t (UR_APICALL *ur_pfnBindlessImagesMapExternalLinearMemoryExp_t)(
     ur_context_handle_t,
     ur_device_handle_t,
     uint64_t,
     uint64_t,
     ur_exp_external_mem_handle_t,
-    void **);
+    void**
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urBindlessImagesReleaseExternalMemoryExp
-typedef ur_result_t(UR_APICALL *ur_pfnBindlessImagesReleaseExternalMemoryExp_t)(
+/// @brief Function-pointer for urBindlessImagesReleaseExternalMemoryExp 
+typedef ur_result_t (UR_APICALL *ur_pfnBindlessImagesReleaseExternalMemoryExp_t)(
     ur_context_handle_t,
     ur_device_handle_t,
-    ur_exp_external_mem_handle_t);
+    ur_exp_external_mem_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urBindlessImagesImportExternalSemaphoreExp
-typedef ur_result_t(UR_APICALL *ur_pfnBindlessImagesImportExternalSemaphoreExp_t)(
+/// @brief Function-pointer for urBindlessImagesImportExternalSemaphoreExp 
+typedef ur_result_t (UR_APICALL *ur_pfnBindlessImagesImportExternalSemaphoreExp_t)(
     ur_context_handle_t,
     ur_device_handle_t,
     ur_exp_external_semaphore_type_t,
-    ur_exp_external_semaphore_desc_t *,
-    ur_exp_external_semaphore_handle_t *);
+    ur_exp_external_semaphore_desc_t*,
+    ur_exp_external_semaphore_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urBindlessImagesReleaseExternalSemaphoreExp
-typedef ur_result_t(UR_APICALL *ur_pfnBindlessImagesReleaseExternalSemaphoreExp_t)(
+/// @brief Function-pointer for urBindlessImagesReleaseExternalSemaphoreExp 
+typedef ur_result_t (UR_APICALL *ur_pfnBindlessImagesReleaseExternalSemaphoreExp_t)(
     ur_context_handle_t,
     ur_device_handle_t,
-    ur_exp_external_semaphore_handle_t);
+    ur_exp_external_semaphore_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urBindlessImagesWaitExternalSemaphoreExp
-typedef ur_result_t(UR_APICALL *ur_pfnBindlessImagesWaitExternalSemaphoreExp_t)(
+/// @brief Function-pointer for urBindlessImagesWaitExternalSemaphoreExp 
+typedef ur_result_t (UR_APICALL *ur_pfnBindlessImagesWaitExternalSemaphoreExp_t)(
     ur_queue_handle_t,
     ur_exp_external_semaphore_handle_t,
     bool,
     uint64_t,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urBindlessImagesSignalExternalSemaphoreExp
-typedef ur_result_t(UR_APICALL *ur_pfnBindlessImagesSignalExternalSemaphoreExp_t)(
+/// @brief Function-pointer for urBindlessImagesSignalExternalSemaphoreExp 
+typedef ur_result_t (UR_APICALL *ur_pfnBindlessImagesSignalExternalSemaphoreExp_t)(
     ur_queue_handle_t,
     ur_exp_external_semaphore_handle_t,
     bool,
     uint64_t,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of BindlessImagesExp functions pointers
-typedef struct ur_bindless_images_exp_dditable_t {
-    ur_pfnBindlessImagesUnsampledImageHandleDestroyExp_t pfnUnsampledImageHandleDestroyExp;
-    ur_pfnBindlessImagesSampledImageHandleDestroyExp_t pfnSampledImageHandleDestroyExp;
-    ur_pfnBindlessImagesImageAllocateExp_t pfnImageAllocateExp;
-    ur_pfnBindlessImagesImageFreeExp_t pfnImageFreeExp;
-    ur_pfnBindlessImagesUnsampledImageCreateExp_t pfnUnsampledImageCreateExp;
-    ur_pfnBindlessImagesSampledImageCreateExp_t pfnSampledImageCreateExp;
-    ur_pfnBindlessImagesImageCopyExp_t pfnImageCopyExp;
-    ur_pfnBindlessImagesImageGetInfoExp_t pfnImageGetInfoExp;
-    ur_pfnBindlessImagesMipmapGetLevelExp_t pfnMipmapGetLevelExp;
-    ur_pfnBindlessImagesMipmapFreeExp_t pfnMipmapFreeExp;
-    ur_pfnBindlessImagesImportExternalMemoryExp_t pfnImportExternalMemoryExp;
-    ur_pfnBindlessImagesMapExternalArrayExp_t pfnMapExternalArrayExp;
-    ur_pfnBindlessImagesMapExternalLinearMemoryExp_t pfnMapExternalLinearMemoryExp;
-    ur_pfnBindlessImagesReleaseExternalMemoryExp_t pfnReleaseExternalMemoryExp;
-    ur_pfnBindlessImagesImportExternalSemaphoreExp_t pfnImportExternalSemaphoreExp;
-    ur_pfnBindlessImagesReleaseExternalSemaphoreExp_t pfnReleaseExternalSemaphoreExp;
-    ur_pfnBindlessImagesWaitExternalSemaphoreExp_t pfnWaitExternalSemaphoreExp;
-    ur_pfnBindlessImagesSignalExternalSemaphoreExp_t pfnSignalExternalSemaphoreExp;
+typedef struct ur_bindless_images_exp_dditable_t
+{
+    ur_pfnBindlessImagesUnsampledImageHandleDestroyExp_t        pfnUnsampledImageHandleDestroyExp;
+    ur_pfnBindlessImagesSampledImageHandleDestroyExp_t          pfnSampledImageHandleDestroyExp;
+    ur_pfnBindlessImagesImageAllocateExp_t                      pfnImageAllocateExp;
+    ur_pfnBindlessImagesImageFreeExp_t                          pfnImageFreeExp;
+    ur_pfnBindlessImagesUnsampledImageCreateExp_t               pfnUnsampledImageCreateExp;
+    ur_pfnBindlessImagesSampledImageCreateExp_t                 pfnSampledImageCreateExp;
+    ur_pfnBindlessImagesImageCopyExp_t                          pfnImageCopyExp;
+    ur_pfnBindlessImagesImageGetInfoExp_t                       pfnImageGetInfoExp;
+    ur_pfnBindlessImagesMipmapGetLevelExp_t                     pfnMipmapGetLevelExp;
+    ur_pfnBindlessImagesMipmapFreeExp_t                         pfnMipmapFreeExp;
+    ur_pfnBindlessImagesImportExternalMemoryExp_t               pfnImportExternalMemoryExp;
+    ur_pfnBindlessImagesMapExternalArrayExp_t                   pfnMapExternalArrayExp;
+    ur_pfnBindlessImagesMapExternalLinearMemoryExp_t            pfnMapExternalLinearMemoryExp;
+    ur_pfnBindlessImagesReleaseExternalMemoryExp_t              pfnReleaseExternalMemoryExp;
+    ur_pfnBindlessImagesImportExternalSemaphoreExp_t            pfnImportExternalSemaphoreExp;
+    ur_pfnBindlessImagesReleaseExternalSemaphoreExp_t           pfnReleaseExternalSemaphoreExp;
+    ur_pfnBindlessImagesWaitExternalSemaphoreExp_t              pfnWaitExternalSemaphoreExp;
+    ur_pfnBindlessImagesSignalExternalSemaphoreExp_t            pfnSignalExternalSemaphoreExp;
 } ur_bindless_images_exp_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1728,99 +1891,110 @@ typedef struct ur_bindless_images_exp_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetBindlessImagesExpProcAddrTable(
-    ur_api_version_t version,                    ///< [in] API version requested
-    ur_bindless_images_exp_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_bindless_images_exp_dditable_t* pDdiTable    ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetBindlessImagesExpProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetBindlessImagesExpProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetBindlessImagesExpProcAddrTable_t)(
     ur_api_version_t,
-    ur_bindless_images_exp_dditable_t *);
+    ur_bindless_images_exp_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urUSMHostAlloc
-typedef ur_result_t(UR_APICALL *ur_pfnUSMHostAlloc_t)(
+/// @brief Function-pointer for urUSMHostAlloc 
+typedef ur_result_t (UR_APICALL *ur_pfnUSMHostAlloc_t)(
     ur_context_handle_t,
-    const ur_usm_desc_t *,
+    const ur_usm_desc_t*,
     ur_usm_pool_handle_t,
     size_t,
-    void **);
+    void**
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urUSMDeviceAlloc
-typedef ur_result_t(UR_APICALL *ur_pfnUSMDeviceAlloc_t)(
+/// @brief Function-pointer for urUSMDeviceAlloc 
+typedef ur_result_t (UR_APICALL *ur_pfnUSMDeviceAlloc_t)(
     ur_context_handle_t,
     ur_device_handle_t,
-    const ur_usm_desc_t *,
+    const ur_usm_desc_t*,
     ur_usm_pool_handle_t,
     size_t,
-    void **);
+    void**
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urUSMSharedAlloc
-typedef ur_result_t(UR_APICALL *ur_pfnUSMSharedAlloc_t)(
+/// @brief Function-pointer for urUSMSharedAlloc 
+typedef ur_result_t (UR_APICALL *ur_pfnUSMSharedAlloc_t)(
     ur_context_handle_t,
     ur_device_handle_t,
-    const ur_usm_desc_t *,
+    const ur_usm_desc_t*,
     ur_usm_pool_handle_t,
     size_t,
-    void **);
+    void**
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urUSMFree
-typedef ur_result_t(UR_APICALL *ur_pfnUSMFree_t)(
+/// @brief Function-pointer for urUSMFree 
+typedef ur_result_t (UR_APICALL *ur_pfnUSMFree_t)(
     ur_context_handle_t,
-    void *);
+    void*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urUSMGetMemAllocInfo
-typedef ur_result_t(UR_APICALL *ur_pfnUSMGetMemAllocInfo_t)(
+/// @brief Function-pointer for urUSMGetMemAllocInfo 
+typedef ur_result_t (UR_APICALL *ur_pfnUSMGetMemAllocInfo_t)(
     ur_context_handle_t,
-    const void *,
+    const void*,
     ur_usm_alloc_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urUSMPoolCreate
-typedef ur_result_t(UR_APICALL *ur_pfnUSMPoolCreate_t)(
+/// @brief Function-pointer for urUSMPoolCreate 
+typedef ur_result_t (UR_APICALL *ur_pfnUSMPoolCreate_t)(
     ur_context_handle_t,
-    ur_usm_pool_desc_t *,
-    ur_usm_pool_handle_t *);
+    ur_usm_pool_desc_t*,
+    ur_usm_pool_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urUSMPoolRetain
-typedef ur_result_t(UR_APICALL *ur_pfnUSMPoolRetain_t)(
-    ur_usm_pool_handle_t);
+/// @brief Function-pointer for urUSMPoolRetain 
+typedef ur_result_t (UR_APICALL *ur_pfnUSMPoolRetain_t)(
+    ur_usm_pool_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urUSMPoolRelease
-typedef ur_result_t(UR_APICALL *ur_pfnUSMPoolRelease_t)(
-    ur_usm_pool_handle_t);
+/// @brief Function-pointer for urUSMPoolRelease 
+typedef ur_result_t (UR_APICALL *ur_pfnUSMPoolRelease_t)(
+    ur_usm_pool_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urUSMPoolGetInfo
-typedef ur_result_t(UR_APICALL *ur_pfnUSMPoolGetInfo_t)(
+/// @brief Function-pointer for urUSMPoolGetInfo 
+typedef ur_result_t (UR_APICALL *ur_pfnUSMPoolGetInfo_t)(
     ur_usm_pool_handle_t,
     ur_usm_pool_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of USM functions pointers
-typedef struct ur_usm_dditable_t {
-    ur_pfnUSMHostAlloc_t pfnHostAlloc;
-    ur_pfnUSMDeviceAlloc_t pfnDeviceAlloc;
-    ur_pfnUSMSharedAlloc_t pfnSharedAlloc;
-    ur_pfnUSMFree_t pfnFree;
-    ur_pfnUSMGetMemAllocInfo_t pfnGetMemAllocInfo;
-    ur_pfnUSMPoolCreate_t pfnPoolCreate;
-    ur_pfnUSMPoolRetain_t pfnPoolRetain;
-    ur_pfnUSMPoolRelease_t pfnPoolRelease;
-    ur_pfnUSMPoolGetInfo_t pfnPoolGetInfo;
+typedef struct ur_usm_dditable_t
+{
+    ur_pfnUSMHostAlloc_t                                        pfnHostAlloc;
+    ur_pfnUSMDeviceAlloc_t                                      pfnDeviceAlloc;
+    ur_pfnUSMSharedAlloc_t                                      pfnSharedAlloc;
+    ur_pfnUSMFree_t                                             pfnFree;
+    ur_pfnUSMGetMemAllocInfo_t                                  pfnGetMemAllocInfo;
+    ur_pfnUSMPoolCreate_t                                       pfnPoolCreate;
+    ur_pfnUSMPoolRetain_t                                       pfnPoolRetain;
+    ur_pfnUSMPoolRelease_t                                      pfnPoolRelease;
+    ur_pfnUSMPoolGetInfo_t                                      pfnPoolGetInfo;
 } ur_usm_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1834,48 +2008,53 @@ typedef struct ur_usm_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetUSMProcAddrTable(
-    ur_api_version_t version,    ///< [in] API version requested
-    ur_usm_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_usm_dditable_t* pDdiTable                    ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetUSMProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetUSMProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetUSMProcAddrTable_t)(
     ur_api_version_t,
-    ur_usm_dditable_t *);
+    ur_usm_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urUSMPitchedAllocExp
-typedef ur_result_t(UR_APICALL *ur_pfnUSMPitchedAllocExp_t)(
+/// @brief Function-pointer for urUSMPitchedAllocExp 
+typedef ur_result_t (UR_APICALL *ur_pfnUSMPitchedAllocExp_t)(
     ur_context_handle_t,
     ur_device_handle_t,
-    const ur_usm_desc_t *,
+    const ur_usm_desc_t*,
     ur_usm_pool_handle_t,
     size_t,
     size_t,
     size_t,
-    void **,
-    size_t *);
+    void**,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urUSMImportExp
-typedef ur_result_t(UR_APICALL *ur_pfnUSMImportExp_t)(
+/// @brief Function-pointer for urUSMImportExp 
+typedef ur_result_t (UR_APICALL *ur_pfnUSMImportExp_t)(
     ur_context_handle_t,
-    void *,
-    size_t);
+    void*,
+    size_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urUSMReleaseExp
-typedef ur_result_t(UR_APICALL *ur_pfnUSMReleaseExp_t)(
+/// @brief Function-pointer for urUSMReleaseExp 
+typedef ur_result_t (UR_APICALL *ur_pfnUSMReleaseExp_t)(
     ur_context_handle_t,
-    void *);
+    void*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of USMExp functions pointers
-typedef struct ur_usm_exp_dditable_t {
-    ur_pfnUSMPitchedAllocExp_t pfnPitchedAllocExp;
-    ur_pfnUSMImportExp_t pfnImportExp;
-    ur_pfnUSMReleaseExp_t pfnReleaseExp;
+typedef struct ur_usm_exp_dditable_t
+{
+    ur_pfnUSMPitchedAllocExp_t                                  pfnPitchedAllocExp;
+    ur_pfnUSMImportExp_t                                        pfnImportExp;
+    ur_pfnUSMReleaseExp_t                                       pfnReleaseExp;
 } ur_usm_exp_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1889,92 +2068,100 @@ typedef struct ur_usm_exp_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetUSMExpProcAddrTable(
-    ur_api_version_t version,        ///< [in] API version requested
-    ur_usm_exp_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_usm_exp_dditable_t* pDdiTable                ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetUSMExpProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetUSMExpProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetUSMExpProcAddrTable_t)(
     ur_api_version_t,
-    ur_usm_exp_dditable_t *);
+    ur_usm_exp_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferCreateExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferCreateExp_t)(
+/// @brief Function-pointer for urCommandBufferCreateExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferCreateExp_t)(
     ur_context_handle_t,
     ur_device_handle_t,
-    const ur_exp_command_buffer_desc_t *,
-    ur_exp_command_buffer_handle_t *);
+    const ur_exp_command_buffer_desc_t*,
+    ur_exp_command_buffer_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferRetainExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferRetainExp_t)(
-    ur_exp_command_buffer_handle_t);
+/// @brief Function-pointer for urCommandBufferRetainExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferRetainExp_t)(
+    ur_exp_command_buffer_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferReleaseExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferReleaseExp_t)(
-    ur_exp_command_buffer_handle_t);
+/// @brief Function-pointer for urCommandBufferReleaseExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferReleaseExp_t)(
+    ur_exp_command_buffer_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferFinalizeExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferFinalizeExp_t)(
-    ur_exp_command_buffer_handle_t);
+/// @brief Function-pointer for urCommandBufferFinalizeExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferFinalizeExp_t)(
+    ur_exp_command_buffer_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferAppendKernelLaunchExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferAppendKernelLaunchExp_t)(
+/// @brief Function-pointer for urCommandBufferAppendKernelLaunchExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferAppendKernelLaunchExp_t)(
     ur_exp_command_buffer_handle_t,
     ur_kernel_handle_t,
     uint32_t,
-    const size_t *,
-    const size_t *,
-    const size_t *,
+    const size_t*,
+    const size_t*,
+    const size_t*,
     uint32_t,
-    ur_kernel_handle_t *,
+    ur_kernel_handle_t*,
     uint32_t,
-    const ur_exp_command_buffer_sync_point_t *,
+    const ur_exp_command_buffer_sync_point_t*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_exp_command_buffer_sync_point_t *,
-    ur_event_handle_t *,
-    ur_exp_command_buffer_command_handle_t *);
+    const ur_event_handle_t*,
+    ur_exp_command_buffer_sync_point_t*,
+    ur_event_handle_t*,
+    ur_exp_command_buffer_command_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferAppendUSMMemcpyExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferAppendUSMMemcpyExp_t)(
+/// @brief Function-pointer for urCommandBufferAppendUSMMemcpyExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferAppendUSMMemcpyExp_t)(
     ur_exp_command_buffer_handle_t,
-    void *,
-    const void *,
+    void*,
+    const void*,
     size_t,
     uint32_t,
-    const ur_exp_command_buffer_sync_point_t *,
+    const ur_exp_command_buffer_sync_point_t*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_exp_command_buffer_sync_point_t *,
-    ur_event_handle_t *,
-    ur_exp_command_buffer_command_handle_t *);
+    const ur_event_handle_t*,
+    ur_exp_command_buffer_sync_point_t*,
+    ur_event_handle_t*,
+    ur_exp_command_buffer_command_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferAppendUSMFillExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferAppendUSMFillExp_t)(
+/// @brief Function-pointer for urCommandBufferAppendUSMFillExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferAppendUSMFillExp_t)(
     ur_exp_command_buffer_handle_t,
-    void *,
-    const void *,
+    void*,
+    const void*,
     size_t,
     size_t,
     uint32_t,
-    const ur_exp_command_buffer_sync_point_t *,
+    const ur_exp_command_buffer_sync_point_t*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_exp_command_buffer_sync_point_t *,
-    ur_event_handle_t *,
-    ur_exp_command_buffer_command_handle_t *);
+    const ur_event_handle_t*,
+    ur_exp_command_buffer_sync_point_t*,
+    ur_event_handle_t*,
+    ur_exp_command_buffer_command_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferAppendMemBufferCopyExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferAppendMemBufferCopyExp_t)(
+/// @brief Function-pointer for urCommandBufferAppendMemBufferCopyExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferAppendMemBufferCopyExp_t)(
     ur_exp_command_buffer_handle_t,
     ur_mem_handle_t,
     ur_mem_handle_t,
@@ -1982,48 +2169,51 @@ typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferAppendMemBufferCopyExp_t)(
     size_t,
     size_t,
     uint32_t,
-    const ur_exp_command_buffer_sync_point_t *,
+    const ur_exp_command_buffer_sync_point_t*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_exp_command_buffer_sync_point_t *,
-    ur_event_handle_t *,
-    ur_exp_command_buffer_command_handle_t *);
+    const ur_event_handle_t*,
+    ur_exp_command_buffer_sync_point_t*,
+    ur_event_handle_t*,
+    ur_exp_command_buffer_command_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferAppendMemBufferWriteExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferAppendMemBufferWriteExp_t)(
+/// @brief Function-pointer for urCommandBufferAppendMemBufferWriteExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferAppendMemBufferWriteExp_t)(
     ur_exp_command_buffer_handle_t,
     ur_mem_handle_t,
     size_t,
     size_t,
-    const void *,
+    const void*,
     uint32_t,
-    const ur_exp_command_buffer_sync_point_t *,
+    const ur_exp_command_buffer_sync_point_t*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_exp_command_buffer_sync_point_t *,
-    ur_event_handle_t *,
-    ur_exp_command_buffer_command_handle_t *);
+    const ur_event_handle_t*,
+    ur_exp_command_buffer_sync_point_t*,
+    ur_event_handle_t*,
+    ur_exp_command_buffer_command_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferAppendMemBufferReadExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferAppendMemBufferReadExp_t)(
+/// @brief Function-pointer for urCommandBufferAppendMemBufferReadExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferAppendMemBufferReadExp_t)(
     ur_exp_command_buffer_handle_t,
     ur_mem_handle_t,
     size_t,
     size_t,
-    void *,
+    void*,
     uint32_t,
-    const ur_exp_command_buffer_sync_point_t *,
+    const ur_exp_command_buffer_sync_point_t*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_exp_command_buffer_sync_point_t *,
-    ur_event_handle_t *,
-    ur_exp_command_buffer_command_handle_t *);
+    const ur_event_handle_t*,
+    ur_exp_command_buffer_sync_point_t*,
+    ur_event_handle_t*,
+    ur_exp_command_buffer_command_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferAppendMemBufferCopyRectExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferAppendMemBufferCopyRectExp_t)(
+/// @brief Function-pointer for urCommandBufferAppendMemBufferCopyRectExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferAppendMemBufferCopyRectExp_t)(
     ur_exp_command_buffer_handle_t,
     ur_mem_handle_t,
     ur_mem_handle_t,
@@ -2035,16 +2225,17 @@ typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferAppendMemBufferCopyRectExp_t)
     size_t,
     size_t,
     uint32_t,
-    const ur_exp_command_buffer_sync_point_t *,
+    const ur_exp_command_buffer_sync_point_t*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_exp_command_buffer_sync_point_t *,
-    ur_event_handle_t *,
-    ur_exp_command_buffer_command_handle_t *);
+    const ur_event_handle_t*,
+    ur_exp_command_buffer_sync_point_t*,
+    ur_event_handle_t*,
+    ur_exp_command_buffer_command_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferAppendMemBufferWriteRectExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferAppendMemBufferWriteRectExp_t)(
+/// @brief Function-pointer for urCommandBufferAppendMemBufferWriteRectExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferAppendMemBufferWriteRectExp_t)(
     ur_exp_command_buffer_handle_t,
     ur_mem_handle_t,
     ur_rect_offset_t,
@@ -2054,18 +2245,19 @@ typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferAppendMemBufferWriteRectExp_t
     size_t,
     size_t,
     size_t,
-    void *,
+    void*,
     uint32_t,
-    const ur_exp_command_buffer_sync_point_t *,
+    const ur_exp_command_buffer_sync_point_t*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_exp_command_buffer_sync_point_t *,
-    ur_event_handle_t *,
-    ur_exp_command_buffer_command_handle_t *);
+    const ur_event_handle_t*,
+    ur_exp_command_buffer_sync_point_t*,
+    ur_event_handle_t*,
+    ur_exp_command_buffer_command_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferAppendMemBufferReadRectExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferAppendMemBufferReadRectExp_t)(
+/// @brief Function-pointer for urCommandBufferAppendMemBufferReadRectExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferAppendMemBufferReadRectExp_t)(
     ur_exp_command_buffer_handle_t,
     ur_mem_handle_t,
     ur_rect_offset_t,
@@ -2075,145 +2267,158 @@ typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferAppendMemBufferReadRectExp_t)
     size_t,
     size_t,
     size_t,
-    void *,
+    void*,
     uint32_t,
-    const ur_exp_command_buffer_sync_point_t *,
+    const ur_exp_command_buffer_sync_point_t*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_exp_command_buffer_sync_point_t *,
-    ur_event_handle_t *,
-    ur_exp_command_buffer_command_handle_t *);
+    const ur_event_handle_t*,
+    ur_exp_command_buffer_sync_point_t*,
+    ur_event_handle_t*,
+    ur_exp_command_buffer_command_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferAppendMemBufferFillExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferAppendMemBufferFillExp_t)(
+/// @brief Function-pointer for urCommandBufferAppendMemBufferFillExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferAppendMemBufferFillExp_t)(
     ur_exp_command_buffer_handle_t,
     ur_mem_handle_t,
-    const void *,
+    const void*,
     size_t,
     size_t,
     size_t,
     uint32_t,
-    const ur_exp_command_buffer_sync_point_t *,
+    const ur_exp_command_buffer_sync_point_t*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_exp_command_buffer_sync_point_t *,
-    ur_event_handle_t *,
-    ur_exp_command_buffer_command_handle_t *);
+    const ur_event_handle_t*,
+    ur_exp_command_buffer_sync_point_t*,
+    ur_event_handle_t*,
+    ur_exp_command_buffer_command_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferAppendUSMPrefetchExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferAppendUSMPrefetchExp_t)(
+/// @brief Function-pointer for urCommandBufferAppendUSMPrefetchExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferAppendUSMPrefetchExp_t)(
     ur_exp_command_buffer_handle_t,
-    const void *,
+    const void*,
     size_t,
     ur_usm_migration_flags_t,
     uint32_t,
-    const ur_exp_command_buffer_sync_point_t *,
+    const ur_exp_command_buffer_sync_point_t*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_exp_command_buffer_sync_point_t *,
-    ur_event_handle_t *,
-    ur_exp_command_buffer_command_handle_t *);
+    const ur_event_handle_t*,
+    ur_exp_command_buffer_sync_point_t*,
+    ur_event_handle_t*,
+    ur_exp_command_buffer_command_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferAppendUSMAdviseExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferAppendUSMAdviseExp_t)(
+/// @brief Function-pointer for urCommandBufferAppendUSMAdviseExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferAppendUSMAdviseExp_t)(
     ur_exp_command_buffer_handle_t,
-    const void *,
+    const void*,
     size_t,
     ur_usm_advice_flags_t,
     uint32_t,
-    const ur_exp_command_buffer_sync_point_t *,
+    const ur_exp_command_buffer_sync_point_t*,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_exp_command_buffer_sync_point_t *,
-    ur_event_handle_t *,
-    ur_exp_command_buffer_command_handle_t *);
+    const ur_event_handle_t*,
+    ur_exp_command_buffer_sync_point_t*,
+    ur_event_handle_t*,
+    ur_exp_command_buffer_command_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferEnqueueExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferEnqueueExp_t)(
+/// @brief Function-pointer for urCommandBufferEnqueueExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferEnqueueExp_t)(
     ur_exp_command_buffer_handle_t,
     ur_queue_handle_t,
     uint32_t,
-    const ur_event_handle_t *,
-    ur_event_handle_t *);
+    const ur_event_handle_t*,
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferRetainCommandExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferRetainCommandExp_t)(
-    ur_exp_command_buffer_command_handle_t);
+/// @brief Function-pointer for urCommandBufferRetainCommandExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferRetainCommandExp_t)(
+    ur_exp_command_buffer_command_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferReleaseCommandExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferReleaseCommandExp_t)(
-    ur_exp_command_buffer_command_handle_t);
+/// @brief Function-pointer for urCommandBufferReleaseCommandExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferReleaseCommandExp_t)(
+    ur_exp_command_buffer_command_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferUpdateKernelLaunchExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferUpdateKernelLaunchExp_t)(
+/// @brief Function-pointer for urCommandBufferUpdateKernelLaunchExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferUpdateKernelLaunchExp_t)(
     ur_exp_command_buffer_command_handle_t,
-    const ur_exp_command_buffer_update_kernel_launch_desc_t *);
+    const ur_exp_command_buffer_update_kernel_launch_desc_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferUpdateSignalEventExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferUpdateSignalEventExp_t)(
+/// @brief Function-pointer for urCommandBufferUpdateSignalEventExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferUpdateSignalEventExp_t)(
     ur_exp_command_buffer_command_handle_t,
-    ur_event_handle_t *);
+    ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferUpdateWaitEventsExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferUpdateWaitEventsExp_t)(
+/// @brief Function-pointer for urCommandBufferUpdateWaitEventsExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferUpdateWaitEventsExp_t)(
     ur_exp_command_buffer_command_handle_t,
     uint32_t,
-    const ur_event_handle_t *);
+    const ur_event_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferGetInfoExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferGetInfoExp_t)(
+/// @brief Function-pointer for urCommandBufferGetInfoExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferGetInfoExp_t)(
     ur_exp_command_buffer_handle_t,
     ur_exp_command_buffer_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urCommandBufferCommandGetInfoExp
-typedef ur_result_t(UR_APICALL *ur_pfnCommandBufferCommandGetInfoExp_t)(
+/// @brief Function-pointer for urCommandBufferCommandGetInfoExp 
+typedef ur_result_t (UR_APICALL *ur_pfnCommandBufferCommandGetInfoExp_t)(
     ur_exp_command_buffer_command_handle_t,
     ur_exp_command_buffer_command_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of CommandBufferExp functions pointers
-typedef struct ur_command_buffer_exp_dditable_t {
-    ur_pfnCommandBufferCreateExp_t pfnCreateExp;
-    ur_pfnCommandBufferRetainExp_t pfnRetainExp;
-    ur_pfnCommandBufferReleaseExp_t pfnReleaseExp;
-    ur_pfnCommandBufferFinalizeExp_t pfnFinalizeExp;
-    ur_pfnCommandBufferAppendKernelLaunchExp_t pfnAppendKernelLaunchExp;
-    ur_pfnCommandBufferAppendUSMMemcpyExp_t pfnAppendUSMMemcpyExp;
-    ur_pfnCommandBufferAppendUSMFillExp_t pfnAppendUSMFillExp;
-    ur_pfnCommandBufferAppendMemBufferCopyExp_t pfnAppendMemBufferCopyExp;
-    ur_pfnCommandBufferAppendMemBufferWriteExp_t pfnAppendMemBufferWriteExp;
-    ur_pfnCommandBufferAppendMemBufferReadExp_t pfnAppendMemBufferReadExp;
-    ur_pfnCommandBufferAppendMemBufferCopyRectExp_t pfnAppendMemBufferCopyRectExp;
-    ur_pfnCommandBufferAppendMemBufferWriteRectExp_t pfnAppendMemBufferWriteRectExp;
-    ur_pfnCommandBufferAppendMemBufferReadRectExp_t pfnAppendMemBufferReadRectExp;
-    ur_pfnCommandBufferAppendMemBufferFillExp_t pfnAppendMemBufferFillExp;
-    ur_pfnCommandBufferAppendUSMPrefetchExp_t pfnAppendUSMPrefetchExp;
-    ur_pfnCommandBufferAppendUSMAdviseExp_t pfnAppendUSMAdviseExp;
-    ur_pfnCommandBufferEnqueueExp_t pfnEnqueueExp;
-    ur_pfnCommandBufferRetainCommandExp_t pfnRetainCommandExp;
-    ur_pfnCommandBufferReleaseCommandExp_t pfnReleaseCommandExp;
-    ur_pfnCommandBufferUpdateKernelLaunchExp_t pfnUpdateKernelLaunchExp;
-    ur_pfnCommandBufferUpdateSignalEventExp_t pfnUpdateSignalEventExp;
-    ur_pfnCommandBufferUpdateWaitEventsExp_t pfnUpdateWaitEventsExp;
-    ur_pfnCommandBufferGetInfoExp_t pfnGetInfoExp;
-    ur_pfnCommandBufferCommandGetInfoExp_t pfnCommandGetInfoExp;
+typedef struct ur_command_buffer_exp_dditable_t
+{
+    ur_pfnCommandBufferCreateExp_t                              pfnCreateExp;
+    ur_pfnCommandBufferRetainExp_t                              pfnRetainExp;
+    ur_pfnCommandBufferReleaseExp_t                             pfnReleaseExp;
+    ur_pfnCommandBufferFinalizeExp_t                            pfnFinalizeExp;
+    ur_pfnCommandBufferAppendKernelLaunchExp_t                  pfnAppendKernelLaunchExp;
+    ur_pfnCommandBufferAppendUSMMemcpyExp_t                     pfnAppendUSMMemcpyExp;
+    ur_pfnCommandBufferAppendUSMFillExp_t                       pfnAppendUSMFillExp;
+    ur_pfnCommandBufferAppendMemBufferCopyExp_t                 pfnAppendMemBufferCopyExp;
+    ur_pfnCommandBufferAppendMemBufferWriteExp_t                pfnAppendMemBufferWriteExp;
+    ur_pfnCommandBufferAppendMemBufferReadExp_t                 pfnAppendMemBufferReadExp;
+    ur_pfnCommandBufferAppendMemBufferCopyRectExp_t             pfnAppendMemBufferCopyRectExp;
+    ur_pfnCommandBufferAppendMemBufferWriteRectExp_t            pfnAppendMemBufferWriteRectExp;
+    ur_pfnCommandBufferAppendMemBufferReadRectExp_t             pfnAppendMemBufferReadRectExp;
+    ur_pfnCommandBufferAppendMemBufferFillExp_t                 pfnAppendMemBufferFillExp;
+    ur_pfnCommandBufferAppendUSMPrefetchExp_t                   pfnAppendUSMPrefetchExp;
+    ur_pfnCommandBufferAppendUSMAdviseExp_t                     pfnAppendUSMAdviseExp;
+    ur_pfnCommandBufferEnqueueExp_t                             pfnEnqueueExp;
+    ur_pfnCommandBufferRetainCommandExp_t                       pfnRetainCommandExp;
+    ur_pfnCommandBufferReleaseCommandExp_t                      pfnReleaseCommandExp;
+    ur_pfnCommandBufferUpdateKernelLaunchExp_t                  pfnUpdateKernelLaunchExp;
+    ur_pfnCommandBufferUpdateSignalEventExp_t                   pfnUpdateSignalEventExp;
+    ur_pfnCommandBufferUpdateWaitEventsExp_t                    pfnUpdateWaitEventsExp;
+    ur_pfnCommandBufferGetInfoExp_t                             pfnGetInfoExp;
+    ur_pfnCommandBufferCommandGetInfoExp_t                      pfnCommandGetInfoExp;
 } ur_command_buffer_exp_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -2227,44 +2432,49 @@ typedef struct ur_command_buffer_exp_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetCommandBufferExpProcAddrTable(
-    ur_api_version_t version,                   ///< [in] API version requested
-    ur_command_buffer_exp_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_command_buffer_exp_dditable_t* pDdiTable     ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetCommandBufferExpProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetCommandBufferExpProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetCommandBufferExpProcAddrTable_t)(
     ur_api_version_t,
-    ur_command_buffer_exp_dditable_t *);
+    ur_command_buffer_exp_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urUsmP2PEnablePeerAccessExp
-typedef ur_result_t(UR_APICALL *ur_pfnUsmP2PEnablePeerAccessExp_t)(
+/// @brief Function-pointer for urUsmP2PEnablePeerAccessExp 
+typedef ur_result_t (UR_APICALL *ur_pfnUsmP2PEnablePeerAccessExp_t)(
     ur_device_handle_t,
-    ur_device_handle_t);
+    ur_device_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urUsmP2PDisablePeerAccessExp
-typedef ur_result_t(UR_APICALL *ur_pfnUsmP2PDisablePeerAccessExp_t)(
+/// @brief Function-pointer for urUsmP2PDisablePeerAccessExp 
+typedef ur_result_t (UR_APICALL *ur_pfnUsmP2PDisablePeerAccessExp_t)(
     ur_device_handle_t,
-    ur_device_handle_t);
+    ur_device_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urUsmP2PPeerAccessGetInfoExp
-typedef ur_result_t(UR_APICALL *ur_pfnUsmP2PPeerAccessGetInfoExp_t)(
+/// @brief Function-pointer for urUsmP2PPeerAccessGetInfoExp 
+typedef ur_result_t (UR_APICALL *ur_pfnUsmP2PPeerAccessGetInfoExp_t)(
     ur_device_handle_t,
     ur_device_handle_t,
     ur_exp_peer_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of UsmP2PExp functions pointers
-typedef struct ur_usm_p2p_exp_dditable_t {
-    ur_pfnUsmP2PEnablePeerAccessExp_t pfnEnablePeerAccessExp;
-    ur_pfnUsmP2PDisablePeerAccessExp_t pfnDisablePeerAccessExp;
-    ur_pfnUsmP2PPeerAccessGetInfoExp_t pfnPeerAccessGetInfoExp;
+typedef struct ur_usm_p2p_exp_dditable_t
+{
+    ur_pfnUsmP2PEnablePeerAccessExp_t                           pfnEnablePeerAccessExp;
+    ur_pfnUsmP2PDisablePeerAccessExp_t                          pfnDisablePeerAccessExp;
+    ur_pfnUsmP2PPeerAccessGetInfoExp_t                          pfnPeerAccessGetInfoExp;
 } ur_usm_p2p_exp_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -2278,87 +2488,96 @@ typedef struct ur_usm_p2p_exp_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetUsmP2PExpProcAddrTable(
-    ur_api_version_t version,            ///< [in] API version requested
-    ur_usm_p2p_exp_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_usm_p2p_exp_dditable_t* pDdiTable            ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetUsmP2PExpProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetUsmP2PExpProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetUsmP2PExpProcAddrTable_t)(
     ur_api_version_t,
-    ur_usm_p2p_exp_dditable_t *);
+    ur_usm_p2p_exp_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urVirtualMemGranularityGetInfo
-typedef ur_result_t(UR_APICALL *ur_pfnVirtualMemGranularityGetInfo_t)(
+/// @brief Function-pointer for urVirtualMemGranularityGetInfo 
+typedef ur_result_t (UR_APICALL *ur_pfnVirtualMemGranularityGetInfo_t)(
     ur_context_handle_t,
     ur_device_handle_t,
     ur_virtual_mem_granularity_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urVirtualMemReserve
-typedef ur_result_t(UR_APICALL *ur_pfnVirtualMemReserve_t)(
+/// @brief Function-pointer for urVirtualMemReserve 
+typedef ur_result_t (UR_APICALL *ur_pfnVirtualMemReserve_t)(
     ur_context_handle_t,
-    const void *,
+    const void*,
     size_t,
-    void **);
+    void**
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urVirtualMemFree
-typedef ur_result_t(UR_APICALL *ur_pfnVirtualMemFree_t)(
+/// @brief Function-pointer for urVirtualMemFree 
+typedef ur_result_t (UR_APICALL *ur_pfnVirtualMemFree_t)(
     ur_context_handle_t,
-    const void *,
-    size_t);
+    const void*,
+    size_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urVirtualMemMap
-typedef ur_result_t(UR_APICALL *ur_pfnVirtualMemMap_t)(
+/// @brief Function-pointer for urVirtualMemMap 
+typedef ur_result_t (UR_APICALL *ur_pfnVirtualMemMap_t)(
     ur_context_handle_t,
-    const void *,
+    const void*,
     size_t,
     ur_physical_mem_handle_t,
     size_t,
-    ur_virtual_mem_access_flags_t);
+    ur_virtual_mem_access_flags_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urVirtualMemUnmap
-typedef ur_result_t(UR_APICALL *ur_pfnVirtualMemUnmap_t)(
+/// @brief Function-pointer for urVirtualMemUnmap 
+typedef ur_result_t (UR_APICALL *ur_pfnVirtualMemUnmap_t)(
     ur_context_handle_t,
-    const void *,
-    size_t);
+    const void*,
+    size_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urVirtualMemSetAccess
-typedef ur_result_t(UR_APICALL *ur_pfnVirtualMemSetAccess_t)(
+/// @brief Function-pointer for urVirtualMemSetAccess 
+typedef ur_result_t (UR_APICALL *ur_pfnVirtualMemSetAccess_t)(
     ur_context_handle_t,
-    const void *,
+    const void*,
     size_t,
-    ur_virtual_mem_access_flags_t);
+    ur_virtual_mem_access_flags_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urVirtualMemGetInfo
-typedef ur_result_t(UR_APICALL *ur_pfnVirtualMemGetInfo_t)(
+/// @brief Function-pointer for urVirtualMemGetInfo 
+typedef ur_result_t (UR_APICALL *ur_pfnVirtualMemGetInfo_t)(
     ur_context_handle_t,
-    const void *,
+    const void*,
     size_t,
     ur_virtual_mem_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of VirtualMem functions pointers
-typedef struct ur_virtual_mem_dditable_t {
-    ur_pfnVirtualMemGranularityGetInfo_t pfnGranularityGetInfo;
-    ur_pfnVirtualMemReserve_t pfnReserve;
-    ur_pfnVirtualMemFree_t pfnFree;
-    ur_pfnVirtualMemMap_t pfnMap;
-    ur_pfnVirtualMemUnmap_t pfnUnmap;
-    ur_pfnVirtualMemSetAccess_t pfnSetAccess;
-    ur_pfnVirtualMemGetInfo_t pfnGetInfo;
+typedef struct ur_virtual_mem_dditable_t
+{
+    ur_pfnVirtualMemGranularityGetInfo_t                        pfnGranularityGetInfo;
+    ur_pfnVirtualMemReserve_t                                   pfnReserve;
+    ur_pfnVirtualMemFree_t                                      pfnFree;
+    ur_pfnVirtualMemMap_t                                       pfnMap;
+    ur_pfnVirtualMemUnmap_t                                     pfnUnmap;
+    ur_pfnVirtualMemSetAccess_t                                 pfnSetAccess;
+    ur_pfnVirtualMemGetInfo_t                                   pfnGetInfo;
 } ur_virtual_mem_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -2372,94 +2591,105 @@ typedef struct ur_virtual_mem_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetVirtualMemProcAddrTable(
-    ur_api_version_t version,            ///< [in] API version requested
-    ur_virtual_mem_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_virtual_mem_dditable_t* pDdiTable            ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetVirtualMemProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetVirtualMemProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetVirtualMemProcAddrTable_t)(
     ur_api_version_t,
-    ur_virtual_mem_dditable_t *);
+    ur_virtual_mem_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urDeviceGet
-typedef ur_result_t(UR_APICALL *ur_pfnDeviceGet_t)(
+/// @brief Function-pointer for urDeviceGet 
+typedef ur_result_t (UR_APICALL *ur_pfnDeviceGet_t)(
     ur_platform_handle_t,
     ur_device_type_t,
     uint32_t,
-    ur_device_handle_t *,
-    uint32_t *);
+    ur_device_handle_t*,
+    uint32_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urDeviceGetInfo
-typedef ur_result_t(UR_APICALL *ur_pfnDeviceGetInfo_t)(
+/// @brief Function-pointer for urDeviceGetInfo 
+typedef ur_result_t (UR_APICALL *ur_pfnDeviceGetInfo_t)(
     ur_device_handle_t,
     ur_device_info_t,
     size_t,
-    void *,
-    size_t *);
+    void*,
+    size_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urDeviceRetain
-typedef ur_result_t(UR_APICALL *ur_pfnDeviceRetain_t)(
-    ur_device_handle_t);
+/// @brief Function-pointer for urDeviceRetain 
+typedef ur_result_t (UR_APICALL *ur_pfnDeviceRetain_t)(
+    ur_device_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urDeviceRelease
-typedef ur_result_t(UR_APICALL *ur_pfnDeviceRelease_t)(
-    ur_device_handle_t);
+/// @brief Function-pointer for urDeviceRelease 
+typedef ur_result_t (UR_APICALL *ur_pfnDeviceRelease_t)(
+    ur_device_handle_t
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urDevicePartition
-typedef ur_result_t(UR_APICALL *ur_pfnDevicePartition_t)(
+/// @brief Function-pointer for urDevicePartition 
+typedef ur_result_t (UR_APICALL *ur_pfnDevicePartition_t)(
     ur_device_handle_t,
-    const ur_device_partition_properties_t *,
+    const ur_device_partition_properties_t*,
     uint32_t,
-    ur_device_handle_t *,
-    uint32_t *);
+    ur_device_handle_t*,
+    uint32_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urDeviceSelectBinary
-typedef ur_result_t(UR_APICALL *ur_pfnDeviceSelectBinary_t)(
+/// @brief Function-pointer for urDeviceSelectBinary 
+typedef ur_result_t (UR_APICALL *ur_pfnDeviceSelectBinary_t)(
     ur_device_handle_t,
-    const ur_device_binary_t *,
+    const ur_device_binary_t*,
     uint32_t,
-    uint32_t *);
+    uint32_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urDeviceGetNativeHandle
-typedef ur_result_t(UR_APICALL *ur_pfnDeviceGetNativeHandle_t)(
+/// @brief Function-pointer for urDeviceGetNativeHandle 
+typedef ur_result_t (UR_APICALL *ur_pfnDeviceGetNativeHandle_t)(
     ur_device_handle_t,
-    ur_native_handle_t *);
+    ur_native_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urDeviceCreateWithNativeHandle
-typedef ur_result_t(UR_APICALL *ur_pfnDeviceCreateWithNativeHandle_t)(
+/// @brief Function-pointer for urDeviceCreateWithNativeHandle 
+typedef ur_result_t (UR_APICALL *ur_pfnDeviceCreateWithNativeHandle_t)(
     ur_native_handle_t,
     ur_adapter_handle_t,
-    const ur_device_native_properties_t *,
-    ur_device_handle_t *);
+    const ur_device_native_properties_t*,
+    ur_device_handle_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Function-pointer for urDeviceGetGlobalTimestamps
-typedef ur_result_t(UR_APICALL *ur_pfnDeviceGetGlobalTimestamps_t)(
+/// @brief Function-pointer for urDeviceGetGlobalTimestamps 
+typedef ur_result_t (UR_APICALL *ur_pfnDeviceGetGlobalTimestamps_t)(
     ur_device_handle_t,
-    uint64_t *,
-    uint64_t *);
+    uint64_t*,
+    uint64_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Table of Device functions pointers
-typedef struct ur_device_dditable_t {
-    ur_pfnDeviceGet_t pfnGet;
-    ur_pfnDeviceGetInfo_t pfnGetInfo;
-    ur_pfnDeviceRetain_t pfnRetain;
-    ur_pfnDeviceRelease_t pfnRelease;
-    ur_pfnDevicePartition_t pfnPartition;
-    ur_pfnDeviceSelectBinary_t pfnSelectBinary;
-    ur_pfnDeviceGetNativeHandle_t pfnGetNativeHandle;
-    ur_pfnDeviceCreateWithNativeHandle_t pfnCreateWithNativeHandle;
-    ur_pfnDeviceGetGlobalTimestamps_t pfnGetGlobalTimestamps;
+typedef struct ur_device_dditable_t
+{
+    ur_pfnDeviceGet_t                                           pfnGet;
+    ur_pfnDeviceGetInfo_t                                       pfnGetInfo;
+    ur_pfnDeviceRetain_t                                        pfnRetain;
+    ur_pfnDeviceRelease_t                                       pfnRelease;
+    ur_pfnDevicePartition_t                                     pfnPartition;
+    ur_pfnDeviceSelectBinary_t                                  pfnSelectBinary;
+    ur_pfnDeviceGetNativeHandle_t                               pfnGetNativeHandle;
+    ur_pfnDeviceCreateWithNativeHandle_t                        pfnCreateWithNativeHandle;
+    ur_pfnDeviceGetGlobalTimestamps_t                           pfnGetGlobalTimestamps;
 } ur_device_dditable_t;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -2473,40 +2703,42 @@ typedef struct ur_device_dditable_t {
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_VERSION
 UR_DLLEXPORT ur_result_t UR_APICALL
 urGetDeviceProcAddrTable(
-    ur_api_version_t version,       ///< [in] API version requested
-    ur_device_dditable_t *pDdiTable ///< [in,out] pointer to table of DDI function pointers
-);
+    ur_api_version_t version,                       ///< [in] API version requested
+    ur_device_dditable_t* pDdiTable                 ///< [in,out] pointer to table of DDI function pointers
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Function-pointer for urGetDeviceProcAddrTable
-typedef ur_result_t(UR_APICALL *ur_pfnGetDeviceProcAddrTable_t)(
+typedef ur_result_t (UR_APICALL *ur_pfnGetDeviceProcAddrTable_t)(
     ur_api_version_t,
-    ur_device_dditable_t *);
+    ur_device_dditable_t*
+    );
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Container for all DDI tables
-typedef struct ur_dditable_t {
-    ur_platform_dditable_t Platform;
-    ur_context_dditable_t Context;
-    ur_event_dditable_t Event;
-    ur_program_dditable_t Program;
-    ur_program_exp_dditable_t ProgramExp;
-    ur_kernel_dditable_t Kernel;
-    ur_kernel_exp_dditable_t KernelExp;
-    ur_queue_dditable_t Queue;
-    ur_sampler_dditable_t Sampler;
-    ur_mem_dditable_t Mem;
-    ur_physical_mem_dditable_t PhysicalMem;
-    ur_global_dditable_t Global;
-    ur_enqueue_dditable_t Enqueue;
-    ur_enqueue_exp_dditable_t EnqueueExp;
-    ur_bindless_images_exp_dditable_t BindlessImagesExp;
-    ur_usm_dditable_t USM;
-    ur_usm_exp_dditable_t USMExp;
-    ur_command_buffer_exp_dditable_t CommandBufferExp;
-    ur_usm_p2p_exp_dditable_t UsmP2PExp;
-    ur_virtual_mem_dditable_t VirtualMem;
-    ur_device_dditable_t Device;
+typedef struct ur_dditable_t
+{
+    ur_platform_dditable_t              Platform;
+    ur_context_dditable_t               Context;
+    ur_event_dditable_t                 Event;
+    ur_program_dditable_t               Program;
+    ur_program_exp_dditable_t           ProgramExp;
+    ur_kernel_dditable_t                Kernel;
+    ur_kernel_exp_dditable_t            KernelExp;
+    ur_queue_dditable_t                 Queue;
+    ur_sampler_dditable_t               Sampler;
+    ur_mem_dditable_t                   Mem;
+    ur_physical_mem_dditable_t          PhysicalMem;
+    ur_global_dditable_t                Global;
+    ur_enqueue_dditable_t               Enqueue;
+    ur_enqueue_exp_dditable_t           EnqueueExp;
+    ur_bindless_images_exp_dditable_t   BindlessImagesExp;
+    ur_usm_dditable_t                   USM;
+    ur_usm_exp_dditable_t               USMExp;
+    ur_command_buffer_exp_dditable_t    CommandBufferExp;
+    ur_usm_p2p_exp_dditable_t           UsmP2PExp;
+    ur_virtual_mem_dditable_t           VirtualMem;
+    ur_device_dditable_t                Device;
 } ur_dditable_t;
 
 #if defined(__cplusplus)
diff --git a/include/ur_print.h b/include/ur_print.h
index 1dd874e5a5..3c1b0b7ed6 100644
--- a/include/ur_print.h
+++ b/include/ur_print.h
@@ -18,13 +18,14 @@
 extern "C" {
 #endif
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_function_t enum
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintFunction(enum ur_function_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintFunction(enum ur_function_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_structure_type_t enum
@@ -32,7 +33,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintFunction(enum ur_function_t value, ch
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintStructureType(enum ur_structure_type_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintStructureType(enum ur_structure_type_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_result_t enum
@@ -40,7 +41,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintStructureType(enum ur_structure_type_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintResult(enum ur_result_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintResult(enum ur_result_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_base_properties_t struct
@@ -48,7 +49,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintResult(enum ur_result_t value, char *
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBaseProperties(const struct ur_base_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBaseProperties(const struct ur_base_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_base_desc_t struct
@@ -56,7 +57,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBaseProperties(const struct ur_base_p
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBaseDesc(const struct ur_base_desc_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBaseDesc(const struct ur_base_desc_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_rect_offset_t struct
@@ -64,7 +65,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBaseDesc(const struct ur_base_desc_t
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintRectOffset(const struct ur_rect_offset_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintRectOffset(const struct ur_rect_offset_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_rect_region_t struct
@@ -72,7 +73,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintRectOffset(const struct ur_rect_offse
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintRectRegion(const struct ur_rect_region_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintRectRegion(const struct ur_rect_region_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_init_flag_t enum
@@ -80,7 +81,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintRectRegion(const struct ur_rect_regio
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceInitFlags(enum ur_device_init_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceInitFlags(enum ur_device_init_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_loader_config_info_t enum
@@ -88,7 +89,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceInitFlags(enum ur_device_init_f
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigInfo(enum ur_loader_config_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigInfo(enum ur_loader_config_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_code_location_t struct
@@ -96,7 +97,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigInfo(enum ur_loader_confi
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCodeLocation(const struct ur_code_location_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCodeLocation(const struct ur_code_location_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_adapter_info_t enum
@@ -104,7 +105,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCodeLocation(const struct ur_code_loc
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterInfo(enum ur_adapter_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterInfo(enum ur_adapter_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_adapter_backend_t enum
@@ -112,7 +113,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterInfo(enum ur_adapter_info_t va
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterBackend(enum ur_adapter_backend_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterBackend(enum ur_adapter_backend_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_platform_info_t enum
@@ -120,7 +121,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterBackend(enum ur_adapter_backen
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformInfo(enum ur_platform_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformInfo(enum ur_platform_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_api_version_t enum
@@ -128,7 +129,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformInfo(enum ur_platform_info_t
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintApiVersion(enum ur_api_version_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintApiVersion(enum ur_api_version_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_platform_native_properties_t struct
@@ -136,7 +137,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintApiVersion(enum ur_api_version_t valu
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformNativeProperties(const struct ur_platform_native_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformNativeProperties(const struct ur_platform_native_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_platform_backend_t enum
@@ -144,7 +145,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformNativeProperties(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformBackend(enum ur_platform_backend_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformBackend(enum ur_platform_backend_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_binary_t struct
@@ -152,7 +153,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformBackend(enum ur_platform_back
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceBinary(const struct ur_device_binary_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceBinary(const struct ur_device_binary_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_type_t enum
@@ -160,7 +161,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceBinary(const struct ur_device_b
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceType(enum ur_device_type_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceType(enum ur_device_type_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_info_t enum
@@ -168,7 +169,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceType(enum ur_device_type_t valu
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceInfo(enum ur_device_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceInfo(enum ur_device_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_affinity_domain_flag_t enum
@@ -176,7 +177,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceInfo(enum ur_device_info_t valu
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceAffinityDomainFlags(enum ur_device_affinity_domain_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceAffinityDomainFlags(enum ur_device_affinity_domain_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_partition_t enum
@@ -184,7 +185,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceAffinityDomainFlags(enum ur_dev
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDevicePartition(enum ur_device_partition_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDevicePartition(enum ur_device_partition_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_partition_property_t struct
@@ -192,7 +193,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDevicePartition(enum ur_device_partit
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDevicePartitionProperty(const struct ur_device_partition_property_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDevicePartitionProperty(const struct ur_device_partition_property_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_partition_properties_t struct
@@ -200,7 +201,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDevicePartitionProperty(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDevicePartitionProperties(const struct ur_device_partition_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDevicePartitionProperties(const struct ur_device_partition_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_fp_capability_flag_t enum
@@ -208,7 +209,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDevicePartitionProperties(const struc
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceFpCapabilityFlags(enum ur_device_fp_capability_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceFpCapabilityFlags(enum ur_device_fp_capability_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_mem_cache_type_t enum
@@ -216,7 +217,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceFpCapabilityFlags(enum ur_devic
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceMemCacheType(enum ur_device_mem_cache_type_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceMemCacheType(enum ur_device_mem_cache_type_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_local_mem_type_t enum
@@ -224,7 +225,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceMemCacheType(enum ur_device_mem
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceLocalMemType(enum ur_device_local_mem_type_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceLocalMemType(enum ur_device_local_mem_type_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_exec_capability_flag_t enum
@@ -232,7 +233,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceLocalMemType(enum ur_device_loc
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceExecCapabilityFlags(enum ur_device_exec_capability_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceExecCapabilityFlags(enum ur_device_exec_capability_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_native_properties_t struct
@@ -240,7 +241,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceExecCapabilityFlags(enum ur_dev
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceNativeProperties(const struct ur_device_native_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceNativeProperties(const struct ur_device_native_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_memory_order_capability_flag_t enum
@@ -248,7 +249,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceNativeProperties(const struct u
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintMemoryOrderCapabilityFlags(enum ur_memory_order_capability_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintMemoryOrderCapabilityFlags(enum ur_memory_order_capability_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_memory_scope_capability_flag_t enum
@@ -256,7 +257,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintMemoryOrderCapabilityFlags(enum ur_me
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintMemoryScopeCapabilityFlags(enum ur_memory_scope_capability_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintMemoryScopeCapabilityFlags(enum ur_memory_scope_capability_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_usm_access_capability_flag_t enum
@@ -264,7 +265,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintMemoryScopeCapabilityFlags(enum ur_me
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceUsmAccessCapabilityFlags(enum ur_device_usm_access_capability_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceUsmAccessCapabilityFlags(enum ur_device_usm_access_capability_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_context_flag_t enum
@@ -272,7 +273,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceUsmAccessCapabilityFlags(enum u
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintContextFlags(enum ur_context_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintContextFlags(enum ur_context_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_context_properties_t struct
@@ -280,7 +281,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintContextFlags(enum ur_context_flag_t v
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintContextProperties(const struct ur_context_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintContextProperties(const struct ur_context_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_context_info_t enum
@@ -288,7 +289,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintContextProperties(const struct ur_con
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintContextInfo(enum ur_context_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintContextInfo(enum ur_context_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_context_native_properties_t struct
@@ -296,7 +297,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintContextInfo(enum ur_context_info_t va
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintContextNativeProperties(const struct ur_context_native_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintContextNativeProperties(const struct ur_context_native_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_mem_flag_t enum
@@ -304,7 +305,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintContextNativeProperties(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintMemFlags(enum ur_mem_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintMemFlags(enum ur_mem_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_mem_type_t enum
@@ -312,7 +313,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintMemFlags(enum ur_mem_flag_t value, ch
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintMemType(enum ur_mem_type_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintMemType(enum ur_mem_type_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_mem_info_t enum
@@ -320,7 +321,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintMemType(enum ur_mem_type_t value, cha
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintMemInfo(enum ur_mem_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintMemInfo(enum ur_mem_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_image_channel_order_t enum
@@ -328,7 +329,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintMemInfo(enum ur_mem_info_t value, cha
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintImageChannelOrder(enum ur_image_channel_order_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintImageChannelOrder(enum ur_image_channel_order_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_image_channel_type_t enum
@@ -336,7 +337,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintImageChannelOrder(enum ur_image_chann
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintImageChannelType(enum ur_image_channel_type_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintImageChannelType(enum ur_image_channel_type_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_image_info_t enum
@@ -344,7 +345,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintImageChannelType(enum ur_image_channe
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintImageInfo(enum ur_image_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintImageInfo(enum ur_image_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_image_format_t struct
@@ -352,7 +353,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintImageInfo(enum ur_image_info_t value,
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintImageFormat(const struct ur_image_format_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintImageFormat(const struct ur_image_format_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_image_desc_t struct
@@ -360,7 +361,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintImageFormat(const struct ur_image_for
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintImageDesc(const struct ur_image_desc_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintImageDesc(const struct ur_image_desc_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_buffer_properties_t struct
@@ -368,7 +369,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintImageDesc(const struct ur_image_desc_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBufferProperties(const struct ur_buffer_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBufferProperties(const struct ur_buffer_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_buffer_channel_properties_t struct
@@ -376,7 +377,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBufferProperties(const struct ur_buff
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBufferChannelProperties(const struct ur_buffer_channel_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBufferChannelProperties(const struct ur_buffer_channel_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_buffer_alloc_location_properties_t struct
@@ -384,7 +385,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBufferChannelProperties(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBufferAllocLocationProperties(const struct ur_buffer_alloc_location_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBufferAllocLocationProperties(const struct ur_buffer_alloc_location_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_buffer_region_t struct
@@ -392,7 +393,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBufferAllocLocationProperties(const s
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBufferRegion(const struct ur_buffer_region_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBufferRegion(const struct ur_buffer_region_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_buffer_create_type_t enum
@@ -400,7 +401,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBufferRegion(const struct ur_buffer_r
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBufferCreateType(enum ur_buffer_create_type_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBufferCreateType(enum ur_buffer_create_type_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_mem_native_properties_t struct
@@ -408,7 +409,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBufferCreateType(enum ur_buffer_creat
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintMemNativeProperties(const struct ur_mem_native_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintMemNativeProperties(const struct ur_mem_native_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_sampler_filter_mode_t enum
@@ -416,7 +417,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintMemNativeProperties(const struct ur_m
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerFilterMode(enum ur_sampler_filter_mode_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerFilterMode(enum ur_sampler_filter_mode_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_sampler_addressing_mode_t enum
@@ -424,7 +425,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerFilterMode(enum ur_sampler_fil
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerAddressingMode(enum ur_sampler_addressing_mode_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerAddressingMode(enum ur_sampler_addressing_mode_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_sampler_info_t enum
@@ -432,7 +433,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerAddressingMode(enum ur_sampler
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerInfo(enum ur_sampler_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerInfo(enum ur_sampler_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_sampler_desc_t struct
@@ -440,7 +441,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerInfo(enum ur_sampler_info_t va
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerDesc(const struct ur_sampler_desc_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerDesc(const struct ur_sampler_desc_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_sampler_native_properties_t struct
@@ -448,7 +449,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerDesc(const struct ur_sampler_d
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerNativeProperties(const struct ur_sampler_native_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerNativeProperties(const struct ur_sampler_native_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_host_mem_flag_t enum
@@ -456,7 +457,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerNativeProperties(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmHostMemFlags(enum ur_usm_host_mem_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmHostMemFlags(enum ur_usm_host_mem_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_device_mem_flag_t enum
@@ -464,7 +465,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmHostMemFlags(enum ur_usm_host_mem_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmDeviceMemFlags(enum ur_usm_device_mem_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmDeviceMemFlags(enum ur_usm_device_mem_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_pool_flag_t enum
@@ -472,7 +473,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmDeviceMemFlags(enum ur_usm_device_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolFlags(enum ur_usm_pool_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolFlags(enum ur_usm_pool_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_type_t enum
@@ -480,7 +481,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolFlags(enum ur_usm_pool_flag_t
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmType(enum ur_usm_type_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmType(enum ur_usm_type_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_alloc_info_t enum
@@ -488,7 +489,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmType(enum ur_usm_type_t value, cha
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmAllocInfo(enum ur_usm_alloc_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmAllocInfo(enum ur_usm_alloc_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_advice_flag_t enum
@@ -496,7 +497,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmAllocInfo(enum ur_usm_alloc_info_t
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmAdviceFlags(enum ur_usm_advice_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmAdviceFlags(enum ur_usm_advice_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_desc_t struct
@@ -504,7 +505,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmAdviceFlags(enum ur_usm_advice_fla
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmDesc(const struct ur_usm_desc_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmDesc(const struct ur_usm_desc_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_host_desc_t struct
@@ -512,7 +513,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmDesc(const struct ur_usm_desc_t pa
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmHostDesc(const struct ur_usm_host_desc_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmHostDesc(const struct ur_usm_host_desc_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_device_desc_t struct
@@ -520,7 +521,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmHostDesc(const struct ur_usm_host_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmDeviceDesc(const struct ur_usm_device_desc_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmDeviceDesc(const struct ur_usm_device_desc_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_alloc_location_desc_t struct
@@ -528,7 +529,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmDeviceDesc(const struct ur_usm_dev
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmAllocLocationDesc(const struct ur_usm_alloc_location_desc_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmAllocLocationDesc(const struct ur_usm_alloc_location_desc_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_pool_desc_t struct
@@ -536,7 +537,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmAllocLocationDesc(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolDesc(const struct ur_usm_pool_desc_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolDesc(const struct ur_usm_pool_desc_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_pool_limits_desc_t struct
@@ -544,7 +545,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolDesc(const struct ur_usm_pool_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolLimitsDesc(const struct ur_usm_pool_limits_desc_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolLimitsDesc(const struct ur_usm_pool_limits_desc_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_pool_info_t enum
@@ -552,7 +553,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolLimitsDesc(const struct ur_usm
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolInfo(enum ur_usm_pool_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolInfo(enum ur_usm_pool_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_virtual_mem_granularity_info_t enum
@@ -560,7 +561,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolInfo(enum ur_usm_pool_info_t v
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemGranularityInfo(enum ur_virtual_mem_granularity_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemGranularityInfo(enum ur_virtual_mem_granularity_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_virtual_mem_access_flag_t enum
@@ -568,7 +569,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemGranularityInfo(enum ur_vir
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemAccessFlags(enum ur_virtual_mem_access_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemAccessFlags(enum ur_virtual_mem_access_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_virtual_mem_info_t enum
@@ -576,7 +577,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemAccessFlags(enum ur_virtual
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemInfo(enum ur_virtual_mem_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemInfo(enum ur_virtual_mem_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_physical_mem_flag_t enum
@@ -584,7 +585,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemInfo(enum ur_virtual_mem_in
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintPhysicalMemFlags(enum ur_physical_mem_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintPhysicalMemFlags(enum ur_physical_mem_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_physical_mem_properties_t struct
@@ -592,7 +593,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintPhysicalMemFlags(enum ur_physical_mem
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintPhysicalMemProperties(const struct ur_physical_mem_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintPhysicalMemProperties(const struct ur_physical_mem_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_metadata_type_t enum
@@ -600,7 +601,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintPhysicalMemProperties(const struct ur
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramMetadataType(enum ur_program_metadata_type_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramMetadataType(enum ur_program_metadata_type_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_metadata_t struct
@@ -608,7 +609,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramMetadataType(enum ur_program_m
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramMetadata(const struct ur_program_metadata_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramMetadata(const struct ur_program_metadata_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_properties_t struct
@@ -616,7 +617,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramMetadata(const struct ur_progr
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramProperties(const struct ur_program_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramProperties(const struct ur_program_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_info_t enum
@@ -624,7 +625,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramProperties(const struct ur_pro
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramInfo(enum ur_program_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramInfo(enum ur_program_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_build_status_t enum
@@ -632,7 +633,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramInfo(enum ur_program_info_t va
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramBuildStatus(enum ur_program_build_status_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramBuildStatus(enum ur_program_build_status_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_binary_type_t enum
@@ -640,7 +641,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramBuildStatus(enum ur_program_bu
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramBinaryType(enum ur_program_binary_type_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramBinaryType(enum ur_program_binary_type_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_build_info_t enum
@@ -648,7 +649,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramBinaryType(enum ur_program_bin
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramBuildInfo(enum ur_program_build_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramBuildInfo(enum ur_program_build_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_specialization_constant_info_t struct
@@ -656,7 +657,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramBuildInfo(enum ur_program_buil
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintSpecializationConstantInfo(const struct ur_specialization_constant_info_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintSpecializationConstantInfo(const struct ur_specialization_constant_info_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_native_properties_t struct
@@ -664,7 +665,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintSpecializationConstantInfo(const stru
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramNativeProperties(const struct ur_program_native_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramNativeProperties(const struct ur_program_native_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_arg_value_properties_t struct
@@ -672,7 +673,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramNativeProperties(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelArgValueProperties(const struct ur_kernel_arg_value_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelArgValueProperties(const struct ur_kernel_arg_value_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_arg_local_properties_t struct
@@ -680,7 +681,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelArgValueProperties(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelArgLocalProperties(const struct ur_kernel_arg_local_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelArgLocalProperties(const struct ur_kernel_arg_local_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_info_t enum
@@ -688,7 +689,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelArgLocalProperties(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelInfo(enum ur_kernel_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelInfo(enum ur_kernel_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_group_info_t enum
@@ -696,7 +697,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelInfo(enum ur_kernel_info_t valu
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelGroupInfo(enum ur_kernel_group_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelGroupInfo(enum ur_kernel_group_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_sub_group_info_t enum
@@ -704,7 +705,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelGroupInfo(enum ur_kernel_group_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSubGroupInfo(enum ur_kernel_sub_group_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSubGroupInfo(enum ur_kernel_sub_group_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_cache_config_t enum
@@ -712,7 +713,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSubGroupInfo(enum ur_kernel_sub
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelCacheConfig(enum ur_kernel_cache_config_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelCacheConfig(enum ur_kernel_cache_config_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_exec_info_t enum
@@ -720,7 +721,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelCacheConfig(enum ur_kernel_cach
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelExecInfo(enum ur_kernel_exec_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelExecInfo(enum ur_kernel_exec_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_arg_pointer_properties_t struct
@@ -728,7 +729,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelExecInfo(enum ur_kernel_exec_in
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelArgPointerProperties(const struct ur_kernel_arg_pointer_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelArgPointerProperties(const struct ur_kernel_arg_pointer_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_exec_info_properties_t struct
@@ -736,7 +737,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelArgPointerProperties(const stru
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelExecInfoProperties(const struct ur_kernel_exec_info_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelExecInfoProperties(const struct ur_kernel_exec_info_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_arg_sampler_properties_t struct
@@ -744,7 +745,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelExecInfoProperties(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelArgSamplerProperties(const struct ur_kernel_arg_sampler_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelArgSamplerProperties(const struct ur_kernel_arg_sampler_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_arg_mem_obj_properties_t struct
@@ -752,7 +753,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelArgSamplerProperties(const stru
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelArgMemObjProperties(const struct ur_kernel_arg_mem_obj_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelArgMemObjProperties(const struct ur_kernel_arg_mem_obj_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_native_properties_t struct
@@ -760,7 +761,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelArgMemObjProperties(const struc
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelNativeProperties(const struct ur_kernel_native_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelNativeProperties(const struct ur_kernel_native_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_queue_info_t enum
@@ -768,7 +769,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelNativeProperties(const struct u
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueInfo(enum ur_queue_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueInfo(enum ur_queue_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_queue_flag_t enum
@@ -776,7 +777,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueInfo(enum ur_queue_info_t value,
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueFlags(enum ur_queue_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueFlags(enum ur_queue_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_queue_properties_t struct
@@ -784,7 +785,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueFlags(enum ur_queue_flag_t value
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueProperties(const struct ur_queue_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueProperties(const struct ur_queue_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_queue_index_properties_t struct
@@ -792,7 +793,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueProperties(const struct ur_queue
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueIndexProperties(const struct ur_queue_index_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueIndexProperties(const struct ur_queue_index_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_queue_native_desc_t struct
@@ -800,7 +801,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueIndexProperties(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueNativeDesc(const struct ur_queue_native_desc_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueNativeDesc(const struct ur_queue_native_desc_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_queue_native_properties_t struct
@@ -808,7 +809,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueNativeDesc(const struct ur_queue
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueNativeProperties(const struct ur_queue_native_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueNativeProperties(const struct ur_queue_native_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_t enum
@@ -816,7 +817,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueNativeProperties(const struct ur
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommand(enum ur_command_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommand(enum ur_command_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_event_status_t enum
@@ -824,7 +825,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommand(enum ur_command_t value, char
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEventStatus(enum ur_event_status_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEventStatus(enum ur_event_status_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_event_info_t enum
@@ -832,7 +833,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEventStatus(enum ur_event_status_t va
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEventInfo(enum ur_event_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEventInfo(enum ur_event_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_profiling_info_t enum
@@ -840,7 +841,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEventInfo(enum ur_event_info_t value,
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProfilingInfo(enum ur_profiling_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProfilingInfo(enum ur_profiling_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_event_native_properties_t struct
@@ -848,7 +849,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProfilingInfo(enum ur_profiling_info_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEventNativeProperties(const struct ur_event_native_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEventNativeProperties(const struct ur_event_native_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_execution_info_t enum
@@ -856,7 +857,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEventNativeProperties(const struct ur
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExecutionInfo(enum ur_execution_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExecutionInfo(enum ur_execution_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_map_flag_t enum
@@ -864,7 +865,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExecutionInfo(enum ur_execution_info_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintMapFlags(enum ur_map_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintMapFlags(enum ur_map_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_migration_flag_t enum
@@ -872,7 +873,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintMapFlags(enum ur_map_flag_t value, ch
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmMigrationFlags(enum ur_usm_migration_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmMigrationFlags(enum ur_usm_migration_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_image_copy_flag_t enum
@@ -880,7 +881,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmMigrationFlags(enum ur_usm_migrati
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpImageCopyFlags(enum ur_exp_image_copy_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpImageCopyFlags(enum ur_exp_image_copy_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_sampler_cubemap_filter_mode_t enum
@@ -888,7 +889,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpImageCopyFlags(enum ur_exp_image_c
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpSamplerCubemapFilterMode(enum ur_exp_sampler_cubemap_filter_mode_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpSamplerCubemapFilterMode(enum ur_exp_sampler_cubemap_filter_mode_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_external_mem_type_t enum
@@ -896,7 +897,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpSamplerCubemapFilterMode(enum ur_e
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpExternalMemType(enum ur_exp_external_mem_type_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpExternalMemType(enum ur_exp_external_mem_type_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_external_semaphore_type_t enum
@@ -904,7 +905,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpExternalMemType(enum ur_exp_extern
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpExternalSemaphoreType(enum ur_exp_external_semaphore_type_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpExternalSemaphoreType(enum ur_exp_external_semaphore_type_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_file_descriptor_t struct
@@ -912,7 +913,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpExternalSemaphoreType(enum ur_exp_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpFileDescriptor(const struct ur_exp_file_descriptor_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpFileDescriptor(const struct ur_exp_file_descriptor_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_win32_handle_t struct
@@ -920,7 +921,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpFileDescriptor(const struct ur_exp
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpWin32Handle(const struct ur_exp_win32_handle_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpWin32Handle(const struct ur_exp_win32_handle_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_sampler_mip_properties_t struct
@@ -928,7 +929,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpWin32Handle(const struct ur_exp_wi
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpSamplerMipProperties(const struct ur_exp_sampler_mip_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpSamplerMipProperties(const struct ur_exp_sampler_mip_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_sampler_addr_modes_t struct
@@ -936,7 +937,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpSamplerMipProperties(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpSamplerAddrModes(const struct ur_exp_sampler_addr_modes_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpSamplerAddrModes(const struct ur_exp_sampler_addr_modes_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_sampler_cubemap_properties_t struct
@@ -944,7 +945,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpSamplerAddrModes(const struct ur_e
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpSamplerCubemapProperties(const struct ur_exp_sampler_cubemap_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpSamplerCubemapProperties(const struct ur_exp_sampler_cubemap_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_external_mem_desc_t struct
@@ -952,7 +953,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpSamplerCubemapProperties(const str
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpExternalMemDesc(const struct ur_exp_external_mem_desc_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpExternalMemDesc(const struct ur_exp_external_mem_desc_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_external_semaphore_desc_t struct
@@ -960,7 +961,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpExternalMemDesc(const struct ur_ex
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpExternalSemaphoreDesc(const struct ur_exp_external_semaphore_desc_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpExternalSemaphoreDesc(const struct ur_exp_external_semaphore_desc_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_image_copy_region_t struct
@@ -968,7 +969,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpExternalSemaphoreDesc(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpImageCopyRegion(const struct ur_exp_image_copy_region_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpImageCopyRegion(const struct ur_exp_image_copy_region_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_command_buffer_update_capability_flag_t enum
@@ -976,7 +977,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpImageCopyRegion(const struct ur_ex
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceCommandBufferUpdateCapabilityFlags(enum ur_device_command_buffer_update_capability_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceCommandBufferUpdateCapabilityFlags(enum ur_device_command_buffer_update_capability_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_command_buffer_info_t enum
@@ -984,7 +985,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceCommandBufferUpdateCapabilityFl
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferInfo(enum ur_exp_command_buffer_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferInfo(enum ur_exp_command_buffer_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_command_buffer_command_info_t enum
@@ -992,7 +993,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferInfo(enum ur_exp_comm
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferCommandInfo(enum ur_exp_command_buffer_command_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferCommandInfo(enum ur_exp_command_buffer_command_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_command_buffer_desc_t struct
@@ -1000,7 +1001,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferCommandInfo(enum ur_e
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferDesc(const struct ur_exp_command_buffer_desc_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferDesc(const struct ur_exp_command_buffer_desc_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_command_buffer_update_memobj_arg_desc_t struct
@@ -1008,7 +1009,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferDesc(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferUpdateMemobjArgDesc(const struct ur_exp_command_buffer_update_memobj_arg_desc_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferUpdateMemobjArgDesc(const struct ur_exp_command_buffer_update_memobj_arg_desc_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_command_buffer_update_pointer_arg_desc_t struct
@@ -1016,7 +1017,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferUpdateMemobjArgDesc(c
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferUpdatePointerArgDesc(const struct ur_exp_command_buffer_update_pointer_arg_desc_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferUpdatePointerArgDesc(const struct ur_exp_command_buffer_update_pointer_arg_desc_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_command_buffer_update_value_arg_desc_t struct
@@ -1024,7 +1025,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferUpdatePointerArgDesc(
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferUpdateValueArgDesc(const struct ur_exp_command_buffer_update_value_arg_desc_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferUpdateValueArgDesc(const struct ur_exp_command_buffer_update_value_arg_desc_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_command_buffer_update_kernel_launch_desc_t struct
@@ -1032,7 +1033,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferUpdateValueArgDesc(co
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferUpdateKernelLaunchDesc(const struct ur_exp_command_buffer_update_kernel_launch_desc_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferUpdateKernelLaunchDesc(const struct ur_exp_command_buffer_update_kernel_launch_desc_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_launch_property_id_t enum
@@ -1040,7 +1041,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferUpdateKernelLaunchDes
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpLaunchPropertyId(enum ur_exp_launch_property_id_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpLaunchPropertyId(enum ur_exp_launch_property_id_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_launch_property_t struct
@@ -1048,7 +1049,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpLaunchPropertyId(enum ur_exp_launc
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpLaunchProperty(const struct ur_exp_launch_property_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpLaunchProperty(const struct ur_exp_launch_property_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_peer_info_t enum
@@ -1056,7 +1057,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpLaunchProperty(const struct ur_exp
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpPeerInfo(enum ur_exp_peer_info_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpPeerInfo(enum ur_exp_peer_info_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_enqueue_native_command_flag_t enum
@@ -1064,7 +1065,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpPeerInfo(enum ur_exp_peer_info_t v
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpEnqueueNativeCommandFlags(enum ur_exp_enqueue_native_command_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpEnqueueNativeCommandFlags(enum ur_exp_enqueue_native_command_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_enqueue_native_command_properties_t struct
@@ -1072,7 +1073,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpEnqueueNativeCommandFlags(enum ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpEnqueueNativeCommandProperties(const struct ur_exp_enqueue_native_command_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpEnqueueNativeCommandProperties(const struct ur_exp_enqueue_native_command_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_loader_config_create_params_t struct
@@ -1080,7 +1081,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpEnqueueNativeCommandProperties(con
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigCreateParams(const struct ur_loader_config_create_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigCreateParams(const struct ur_loader_config_create_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_loader_config_retain_params_t struct
@@ -1088,7 +1089,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigCreateParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigRetainParams(const struct ur_loader_config_retain_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigRetainParams(const struct ur_loader_config_retain_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_loader_config_release_params_t struct
@@ -1096,7 +1097,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigRetainParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigReleaseParams(const struct ur_loader_config_release_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigReleaseParams(const struct ur_loader_config_release_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_loader_config_get_info_params_t struct
@@ -1104,7 +1105,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigReleaseParams(const struc
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigGetInfoParams(const struct ur_loader_config_get_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigGetInfoParams(const struct ur_loader_config_get_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_loader_config_enable_layer_params_t struct
@@ -1112,7 +1113,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigGetInfoParams(const struc
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigEnableLayerParams(const struct ur_loader_config_enable_layer_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigEnableLayerParams(const struct ur_loader_config_enable_layer_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_loader_config_set_code_location_callback_params_t struct
@@ -1120,7 +1121,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigEnableLayerParams(const s
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigSetCodeLocationCallbackParams(const struct ur_loader_config_set_code_location_callback_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigSetCodeLocationCallbackParams(const struct ur_loader_config_set_code_location_callback_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_loader_config_set_mocking_enabled_params_t struct
@@ -1128,7 +1129,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigSetCodeLocationCallbackPa
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigSetMockingEnabledParams(const struct ur_loader_config_set_mocking_enabled_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigSetMockingEnabledParams(const struct ur_loader_config_set_mocking_enabled_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_platform_get_params_t struct
@@ -1136,7 +1137,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderConfigSetMockingEnabledParams(c
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformGetParams(const struct ur_platform_get_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformGetParams(const struct ur_platform_get_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_platform_get_info_params_t struct
@@ -1144,7 +1145,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformGetParams(const struct ur_pla
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformGetInfoParams(const struct ur_platform_get_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformGetInfoParams(const struct ur_platform_get_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_platform_get_native_handle_params_t struct
@@ -1152,7 +1153,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformGetInfoParams(const struct ur
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformGetNativeHandleParams(const struct ur_platform_get_native_handle_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformGetNativeHandleParams(const struct ur_platform_get_native_handle_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_platform_create_with_native_handle_params_t struct
@@ -1160,7 +1161,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformGetNativeHandleParams(const s
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformCreateWithNativeHandleParams(const struct ur_platform_create_with_native_handle_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformCreateWithNativeHandleParams(const struct ur_platform_create_with_native_handle_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_platform_get_api_version_params_t struct
@@ -1168,7 +1169,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformCreateWithNativeHandleParams(
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformGetApiVersionParams(const struct ur_platform_get_api_version_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformGetApiVersionParams(const struct ur_platform_get_api_version_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_platform_get_backend_option_params_t struct
@@ -1176,7 +1177,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformGetApiVersionParams(const str
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformGetBackendOptionParams(const struct ur_platform_get_backend_option_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformGetBackendOptionParams(const struct ur_platform_get_backend_option_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_context_create_params_t struct
@@ -1184,7 +1185,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintPlatformGetBackendOptionParams(const
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintContextCreateParams(const struct ur_context_create_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintContextCreateParams(const struct ur_context_create_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_context_retain_params_t struct
@@ -1192,7 +1193,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintContextCreateParams(const struct ur_c
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintContextRetainParams(const struct ur_context_retain_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintContextRetainParams(const struct ur_context_retain_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_context_release_params_t struct
@@ -1200,7 +1201,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintContextRetainParams(const struct ur_c
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintContextReleaseParams(const struct ur_context_release_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintContextReleaseParams(const struct ur_context_release_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_context_get_info_params_t struct
@@ -1208,7 +1209,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintContextReleaseParams(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintContextGetInfoParams(const struct ur_context_get_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintContextGetInfoParams(const struct ur_context_get_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_context_get_native_handle_params_t struct
@@ -1216,7 +1217,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintContextGetInfoParams(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintContextGetNativeHandleParams(const struct ur_context_get_native_handle_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintContextGetNativeHandleParams(const struct ur_context_get_native_handle_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_context_create_with_native_handle_params_t struct
@@ -1224,7 +1225,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintContextGetNativeHandleParams(const st
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintContextCreateWithNativeHandleParams(const struct ur_context_create_with_native_handle_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintContextCreateWithNativeHandleParams(const struct ur_context_create_with_native_handle_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_context_set_extended_deleter_params_t struct
@@ -1232,7 +1233,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintContextCreateWithNativeHandleParams(c
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintContextSetExtendedDeleterParams(const struct ur_context_set_extended_deleter_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintContextSetExtendedDeleterParams(const struct ur_context_set_extended_deleter_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_event_get_info_params_t struct
@@ -1240,7 +1241,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintContextSetExtendedDeleterParams(const
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEventGetInfoParams(const struct ur_event_get_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEventGetInfoParams(const struct ur_event_get_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_event_get_profiling_info_params_t struct
@@ -1248,7 +1249,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEventGetInfoParams(const struct ur_ev
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEventGetProfilingInfoParams(const struct ur_event_get_profiling_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEventGetProfilingInfoParams(const struct ur_event_get_profiling_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_event_wait_params_t struct
@@ -1256,7 +1257,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEventGetProfilingInfoParams(const str
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEventWaitParams(const struct ur_event_wait_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEventWaitParams(const struct ur_event_wait_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_event_retain_params_t struct
@@ -1264,7 +1265,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEventWaitParams(const struct ur_event
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEventRetainParams(const struct ur_event_retain_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEventRetainParams(const struct ur_event_retain_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_event_release_params_t struct
@@ -1272,7 +1273,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEventRetainParams(const struct ur_eve
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEventReleaseParams(const struct ur_event_release_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEventReleaseParams(const struct ur_event_release_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_event_get_native_handle_params_t struct
@@ -1280,7 +1281,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEventReleaseParams(const struct ur_ev
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEventGetNativeHandleParams(const struct ur_event_get_native_handle_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEventGetNativeHandleParams(const struct ur_event_get_native_handle_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_event_create_with_native_handle_params_t struct
@@ -1288,7 +1289,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEventGetNativeHandleParams(const stru
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEventCreateWithNativeHandleParams(const struct ur_event_create_with_native_handle_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEventCreateWithNativeHandleParams(const struct ur_event_create_with_native_handle_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_event_set_callback_params_t struct
@@ -1296,7 +1297,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEventCreateWithNativeHandleParams(con
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEventSetCallbackParams(const struct ur_event_set_callback_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEventSetCallbackParams(const struct ur_event_set_callback_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_create_with_il_params_t struct
@@ -1304,7 +1305,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEventSetCallbackParams(const struct u
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramCreateWithIlParams(const struct ur_program_create_with_il_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramCreateWithIlParams(const struct ur_program_create_with_il_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_create_with_binary_params_t struct
@@ -1312,7 +1313,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramCreateWithIlParams(const struc
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramCreateWithBinaryParams(const struct ur_program_create_with_binary_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramCreateWithBinaryParams(const struct ur_program_create_with_binary_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_build_params_t struct
@@ -1320,7 +1321,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramCreateWithBinaryParams(const s
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramBuildParams(const struct ur_program_build_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramBuildParams(const struct ur_program_build_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_build_exp_params_t struct
@@ -1328,7 +1329,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramBuildParams(const struct ur_pr
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramBuildExpParams(const struct ur_program_build_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramBuildExpParams(const struct ur_program_build_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_compile_params_t struct
@@ -1336,7 +1337,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramBuildExpParams(const struct ur
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramCompileParams(const struct ur_program_compile_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramCompileParams(const struct ur_program_compile_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_compile_exp_params_t struct
@@ -1344,7 +1345,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramCompileParams(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramCompileExpParams(const struct ur_program_compile_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramCompileExpParams(const struct ur_program_compile_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_link_params_t struct
@@ -1352,7 +1353,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramCompileExpParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramLinkParams(const struct ur_program_link_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramLinkParams(const struct ur_program_link_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_link_exp_params_t struct
@@ -1360,7 +1361,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramLinkParams(const struct ur_pro
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramLinkExpParams(const struct ur_program_link_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramLinkExpParams(const struct ur_program_link_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_retain_params_t struct
@@ -1368,7 +1369,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramLinkExpParams(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramRetainParams(const struct ur_program_retain_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramRetainParams(const struct ur_program_retain_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_release_params_t struct
@@ -1376,7 +1377,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramRetainParams(const struct ur_p
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramReleaseParams(const struct ur_program_release_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramReleaseParams(const struct ur_program_release_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_get_function_pointer_params_t struct
@@ -1384,7 +1385,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramReleaseParams(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramGetFunctionPointerParams(const struct ur_program_get_function_pointer_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramGetFunctionPointerParams(const struct ur_program_get_function_pointer_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_get_global_variable_pointer_params_t struct
@@ -1392,7 +1393,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramGetFunctionPointerParams(const
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramGetGlobalVariablePointerParams(const struct ur_program_get_global_variable_pointer_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramGetGlobalVariablePointerParams(const struct ur_program_get_global_variable_pointer_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_get_info_params_t struct
@@ -1400,7 +1401,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramGetGlobalVariablePointerParams
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramGetInfoParams(const struct ur_program_get_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramGetInfoParams(const struct ur_program_get_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_get_build_info_params_t struct
@@ -1408,7 +1409,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramGetInfoParams(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramGetBuildInfoParams(const struct ur_program_get_build_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramGetBuildInfoParams(const struct ur_program_get_build_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_set_specialization_constants_params_t struct
@@ -1416,7 +1417,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramGetBuildInfoParams(const struc
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramSetSpecializationConstantsParams(const struct ur_program_set_specialization_constants_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramSetSpecializationConstantsParams(const struct ur_program_set_specialization_constants_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_get_native_handle_params_t struct
@@ -1424,7 +1425,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramSetSpecializationConstantsPara
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramGetNativeHandleParams(const struct ur_program_get_native_handle_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramGetNativeHandleParams(const struct ur_program_get_native_handle_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_program_create_with_native_handle_params_t struct
@@ -1432,7 +1433,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramGetNativeHandleParams(const st
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramCreateWithNativeHandleParams(const struct ur_program_create_with_native_handle_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramCreateWithNativeHandleParams(const struct ur_program_create_with_native_handle_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_create_params_t struct
@@ -1440,7 +1441,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintProgramCreateWithNativeHandleParams(c
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelCreateParams(const struct ur_kernel_create_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelCreateParams(const struct ur_kernel_create_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_get_info_params_t struct
@@ -1448,7 +1449,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelCreateParams(const struct ur_ke
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelGetInfoParams(const struct ur_kernel_get_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelGetInfoParams(const struct ur_kernel_get_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_get_group_info_params_t struct
@@ -1456,7 +1457,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelGetInfoParams(const struct ur_k
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelGetGroupInfoParams(const struct ur_kernel_get_group_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelGetGroupInfoParams(const struct ur_kernel_get_group_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_get_sub_group_info_params_t struct
@@ -1464,7 +1465,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelGetGroupInfoParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelGetSubGroupInfoParams(const struct ur_kernel_get_sub_group_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelGetSubGroupInfoParams(const struct ur_kernel_get_sub_group_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_retain_params_t struct
@@ -1472,7 +1473,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelGetSubGroupInfoParams(const str
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelRetainParams(const struct ur_kernel_retain_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelRetainParams(const struct ur_kernel_retain_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_release_params_t struct
@@ -1480,7 +1481,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelRetainParams(const struct ur_ke
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelReleaseParams(const struct ur_kernel_release_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelReleaseParams(const struct ur_kernel_release_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_get_native_handle_params_t struct
@@ -1488,7 +1489,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelReleaseParams(const struct ur_k
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelGetNativeHandleParams(const struct ur_kernel_get_native_handle_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelGetNativeHandleParams(const struct ur_kernel_get_native_handle_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_create_with_native_handle_params_t struct
@@ -1496,7 +1497,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelGetNativeHandleParams(const str
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelCreateWithNativeHandleParams(const struct ur_kernel_create_with_native_handle_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelCreateWithNativeHandleParams(const struct ur_kernel_create_with_native_handle_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_get_suggested_local_work_size_params_t struct
@@ -1504,7 +1505,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelCreateWithNativeHandleParams(co
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelGetSuggestedLocalWorkSizeParams(const struct ur_kernel_get_suggested_local_work_size_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelGetSuggestedLocalWorkSizeParams(const struct ur_kernel_get_suggested_local_work_size_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_set_arg_value_params_t struct
@@ -1512,7 +1513,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelGetSuggestedLocalWorkSizeParams
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetArgValueParams(const struct ur_kernel_set_arg_value_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetArgValueParams(const struct ur_kernel_set_arg_value_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_set_arg_local_params_t struct
@@ -1520,7 +1521,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetArgValueParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetArgLocalParams(const struct ur_kernel_set_arg_local_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetArgLocalParams(const struct ur_kernel_set_arg_local_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_set_arg_pointer_params_t struct
@@ -1528,7 +1529,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetArgLocalParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetArgPointerParams(const struct ur_kernel_set_arg_pointer_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetArgPointerParams(const struct ur_kernel_set_arg_pointer_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_set_exec_info_params_t struct
@@ -1536,7 +1537,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetArgPointerParams(const struc
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetExecInfoParams(const struct ur_kernel_set_exec_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetExecInfoParams(const struct ur_kernel_set_exec_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_set_arg_sampler_params_t struct
@@ -1544,7 +1545,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetExecInfoParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetArgSamplerParams(const struct ur_kernel_set_arg_sampler_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetArgSamplerParams(const struct ur_kernel_set_arg_sampler_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_set_arg_mem_obj_params_t struct
@@ -1552,7 +1553,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetArgSamplerParams(const struc
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetArgMemObjParams(const struct ur_kernel_set_arg_mem_obj_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetArgMemObjParams(const struct ur_kernel_set_arg_mem_obj_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_set_specialization_constants_params_t struct
@@ -1560,7 +1561,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetArgMemObjParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetSpecializationConstantsParams(const struct ur_kernel_set_specialization_constants_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetSpecializationConstantsParams(const struct ur_kernel_set_specialization_constants_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_kernel_suggest_max_cooperative_group_count_exp_params_t struct
@@ -1568,7 +1569,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSetSpecializationConstantsParam
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSuggestMaxCooperativeGroupCountExpParams(const struct ur_kernel_suggest_max_cooperative_group_count_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSuggestMaxCooperativeGroupCountExpParams(const struct ur_kernel_suggest_max_cooperative_group_count_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_queue_get_info_params_t struct
@@ -1576,7 +1577,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintKernelSuggestMaxCooperativeGroupCount
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueGetInfoParams(const struct ur_queue_get_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueGetInfoParams(const struct ur_queue_get_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_queue_create_params_t struct
@@ -1584,7 +1585,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueGetInfoParams(const struct ur_qu
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueCreateParams(const struct ur_queue_create_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueCreateParams(const struct ur_queue_create_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_queue_retain_params_t struct
@@ -1592,7 +1593,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueCreateParams(const struct ur_que
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueRetainParams(const struct ur_queue_retain_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueRetainParams(const struct ur_queue_retain_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_queue_release_params_t struct
@@ -1600,7 +1601,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueRetainParams(const struct ur_que
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueReleaseParams(const struct ur_queue_release_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueReleaseParams(const struct ur_queue_release_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_queue_get_native_handle_params_t struct
@@ -1608,7 +1609,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueReleaseParams(const struct ur_qu
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueGetNativeHandleParams(const struct ur_queue_get_native_handle_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueGetNativeHandleParams(const struct ur_queue_get_native_handle_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_queue_create_with_native_handle_params_t struct
@@ -1616,7 +1617,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueGetNativeHandleParams(const stru
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueCreateWithNativeHandleParams(const struct ur_queue_create_with_native_handle_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueCreateWithNativeHandleParams(const struct ur_queue_create_with_native_handle_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_queue_finish_params_t struct
@@ -1624,7 +1625,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueCreateWithNativeHandleParams(con
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueFinishParams(const struct ur_queue_finish_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueFinishParams(const struct ur_queue_finish_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_queue_flush_params_t struct
@@ -1632,7 +1633,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueFinishParams(const struct ur_que
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueFlushParams(const struct ur_queue_flush_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueFlushParams(const struct ur_queue_flush_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_sampler_create_params_t struct
@@ -1640,7 +1641,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintQueueFlushParams(const struct ur_queu
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerCreateParams(const struct ur_sampler_create_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerCreateParams(const struct ur_sampler_create_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_sampler_retain_params_t struct
@@ -1648,7 +1649,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerCreateParams(const struct ur_s
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerRetainParams(const struct ur_sampler_retain_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerRetainParams(const struct ur_sampler_retain_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_sampler_release_params_t struct
@@ -1656,7 +1657,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerRetainParams(const struct ur_s
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerReleaseParams(const struct ur_sampler_release_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerReleaseParams(const struct ur_sampler_release_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_sampler_get_info_params_t struct
@@ -1664,7 +1665,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerReleaseParams(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerGetInfoParams(const struct ur_sampler_get_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerGetInfoParams(const struct ur_sampler_get_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_sampler_get_native_handle_params_t struct
@@ -1672,7 +1673,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerGetInfoParams(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerGetNativeHandleParams(const struct ur_sampler_get_native_handle_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerGetNativeHandleParams(const struct ur_sampler_get_native_handle_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_sampler_create_with_native_handle_params_t struct
@@ -1680,7 +1681,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerGetNativeHandleParams(const st
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerCreateWithNativeHandleParams(const struct ur_sampler_create_with_native_handle_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerCreateWithNativeHandleParams(const struct ur_sampler_create_with_native_handle_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_mem_image_create_params_t struct
@@ -1688,7 +1689,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintSamplerCreateWithNativeHandleParams(c
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintMemImageCreateParams(const struct ur_mem_image_create_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintMemImageCreateParams(const struct ur_mem_image_create_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_mem_buffer_create_params_t struct
@@ -1696,7 +1697,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintMemImageCreateParams(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintMemBufferCreateParams(const struct ur_mem_buffer_create_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintMemBufferCreateParams(const struct ur_mem_buffer_create_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_mem_retain_params_t struct
@@ -1704,7 +1705,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintMemBufferCreateParams(const struct ur
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintMemRetainParams(const struct ur_mem_retain_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintMemRetainParams(const struct ur_mem_retain_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_mem_release_params_t struct
@@ -1712,7 +1713,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintMemRetainParams(const struct ur_mem_r
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintMemReleaseParams(const struct ur_mem_release_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintMemReleaseParams(const struct ur_mem_release_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_mem_buffer_partition_params_t struct
@@ -1720,7 +1721,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintMemReleaseParams(const struct ur_mem_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintMemBufferPartitionParams(const struct ur_mem_buffer_partition_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintMemBufferPartitionParams(const struct ur_mem_buffer_partition_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_mem_get_native_handle_params_t struct
@@ -1728,7 +1729,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintMemBufferPartitionParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintMemGetNativeHandleParams(const struct ur_mem_get_native_handle_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintMemGetNativeHandleParams(const struct ur_mem_get_native_handle_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_mem_buffer_create_with_native_handle_params_t struct
@@ -1736,7 +1737,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintMemGetNativeHandleParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintMemBufferCreateWithNativeHandleParams(const struct ur_mem_buffer_create_with_native_handle_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintMemBufferCreateWithNativeHandleParams(const struct ur_mem_buffer_create_with_native_handle_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_mem_image_create_with_native_handle_params_t struct
@@ -1744,7 +1745,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintMemBufferCreateWithNativeHandleParams
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintMemImageCreateWithNativeHandleParams(const struct ur_mem_image_create_with_native_handle_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintMemImageCreateWithNativeHandleParams(const struct ur_mem_image_create_with_native_handle_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_mem_get_info_params_t struct
@@ -1752,7 +1753,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintMemImageCreateWithNativeHandleParams(
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintMemGetInfoParams(const struct ur_mem_get_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintMemGetInfoParams(const struct ur_mem_get_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_mem_image_get_info_params_t struct
@@ -1760,7 +1761,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintMemGetInfoParams(const struct ur_mem_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintMemImageGetInfoParams(const struct ur_mem_image_get_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintMemImageGetInfoParams(const struct ur_mem_image_get_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_physical_mem_create_params_t struct
@@ -1768,7 +1769,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintMemImageGetInfoParams(const struct ur
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintPhysicalMemCreateParams(const struct ur_physical_mem_create_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintPhysicalMemCreateParams(const struct ur_physical_mem_create_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_physical_mem_retain_params_t struct
@@ -1776,7 +1777,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintPhysicalMemCreateParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintPhysicalMemRetainParams(const struct ur_physical_mem_retain_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintPhysicalMemRetainParams(const struct ur_physical_mem_retain_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_physical_mem_release_params_t struct
@@ -1784,7 +1785,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintPhysicalMemRetainParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintPhysicalMemReleaseParams(const struct ur_physical_mem_release_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintPhysicalMemReleaseParams(const struct ur_physical_mem_release_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_adapter_get_params_t struct
@@ -1792,7 +1793,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintPhysicalMemReleaseParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterGetParams(const struct ur_adapter_get_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterGetParams(const struct ur_adapter_get_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_adapter_release_params_t struct
@@ -1800,7 +1801,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterGetParams(const struct ur_adap
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterReleaseParams(const struct ur_adapter_release_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterReleaseParams(const struct ur_adapter_release_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_adapter_retain_params_t struct
@@ -1808,7 +1809,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterReleaseParams(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterRetainParams(const struct ur_adapter_retain_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterRetainParams(const struct ur_adapter_retain_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_adapter_get_last_error_params_t struct
@@ -1816,7 +1817,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterRetainParams(const struct ur_a
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterGetLastErrorParams(const struct ur_adapter_get_last_error_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterGetLastErrorParams(const struct ur_adapter_get_last_error_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_adapter_get_info_params_t struct
@@ -1824,7 +1825,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterGetLastErrorParams(const struc
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterGetInfoParams(const struct ur_adapter_get_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterGetInfoParams(const struct ur_adapter_get_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_kernel_launch_params_t struct
@@ -1832,7 +1833,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintAdapterGetInfoParams(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueKernelLaunchParams(const struct ur_enqueue_kernel_launch_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueKernelLaunchParams(const struct ur_enqueue_kernel_launch_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_events_wait_params_t struct
@@ -1840,7 +1841,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueKernelLaunchParams(const struc
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueEventsWaitParams(const struct ur_enqueue_events_wait_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueEventsWaitParams(const struct ur_enqueue_events_wait_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_events_wait_with_barrier_params_t struct
@@ -1848,7 +1849,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueEventsWaitParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueEventsWaitWithBarrierParams(const struct ur_enqueue_events_wait_with_barrier_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueEventsWaitWithBarrierParams(const struct ur_enqueue_events_wait_with_barrier_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_mem_buffer_read_params_t struct
@@ -1856,7 +1857,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueEventsWaitWithBarrierParams(co
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferReadParams(const struct ur_enqueue_mem_buffer_read_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferReadParams(const struct ur_enqueue_mem_buffer_read_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_mem_buffer_write_params_t struct
@@ -1864,7 +1865,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferReadParams(const stru
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferWriteParams(const struct ur_enqueue_mem_buffer_write_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferWriteParams(const struct ur_enqueue_mem_buffer_write_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_mem_buffer_read_rect_params_t struct
@@ -1872,7 +1873,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferWriteParams(const str
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferReadRectParams(const struct ur_enqueue_mem_buffer_read_rect_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferReadRectParams(const struct ur_enqueue_mem_buffer_read_rect_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_mem_buffer_write_rect_params_t struct
@@ -1880,7 +1881,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferReadRectParams(const
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferWriteRectParams(const struct ur_enqueue_mem_buffer_write_rect_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferWriteRectParams(const struct ur_enqueue_mem_buffer_write_rect_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_mem_buffer_copy_params_t struct
@@ -1888,7 +1889,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferWriteRectParams(const
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferCopyParams(const struct ur_enqueue_mem_buffer_copy_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferCopyParams(const struct ur_enqueue_mem_buffer_copy_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_mem_buffer_copy_rect_params_t struct
@@ -1896,7 +1897,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferCopyParams(const stru
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferCopyRectParams(const struct ur_enqueue_mem_buffer_copy_rect_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferCopyRectParams(const struct ur_enqueue_mem_buffer_copy_rect_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_mem_buffer_fill_params_t struct
@@ -1904,7 +1905,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferCopyRectParams(const
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferFillParams(const struct ur_enqueue_mem_buffer_fill_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferFillParams(const struct ur_enqueue_mem_buffer_fill_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_mem_image_read_params_t struct
@@ -1912,7 +1913,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferFillParams(const stru
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemImageReadParams(const struct ur_enqueue_mem_image_read_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemImageReadParams(const struct ur_enqueue_mem_image_read_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_mem_image_write_params_t struct
@@ -1920,7 +1921,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemImageReadParams(const struc
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemImageWriteParams(const struct ur_enqueue_mem_image_write_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemImageWriteParams(const struct ur_enqueue_mem_image_write_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_mem_image_copy_params_t struct
@@ -1928,7 +1929,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemImageWriteParams(const stru
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemImageCopyParams(const struct ur_enqueue_mem_image_copy_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemImageCopyParams(const struct ur_enqueue_mem_image_copy_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_mem_buffer_map_params_t struct
@@ -1936,7 +1937,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemImageCopyParams(const struc
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferMapParams(const struct ur_enqueue_mem_buffer_map_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferMapParams(const struct ur_enqueue_mem_buffer_map_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_mem_unmap_params_t struct
@@ -1944,7 +1945,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemBufferMapParams(const struc
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemUnmapParams(const struct ur_enqueue_mem_unmap_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemUnmapParams(const struct ur_enqueue_mem_unmap_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_usm_fill_params_t struct
@@ -1952,7 +1953,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueMemUnmapParams(const struct ur
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueUsmFillParams(const struct ur_enqueue_usm_fill_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueUsmFillParams(const struct ur_enqueue_usm_fill_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_usm_memcpy_params_t struct
@@ -1960,7 +1961,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueUsmFillParams(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueUsmMemcpyParams(const struct ur_enqueue_usm_memcpy_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueUsmMemcpyParams(const struct ur_enqueue_usm_memcpy_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_usm_prefetch_params_t struct
@@ -1968,7 +1969,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueUsmMemcpyParams(const struct u
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueUsmPrefetchParams(const struct ur_enqueue_usm_prefetch_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueUsmPrefetchParams(const struct ur_enqueue_usm_prefetch_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_usm_advise_params_t struct
@@ -1976,7 +1977,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueUsmPrefetchParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueUsmAdviseParams(const struct ur_enqueue_usm_advise_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueUsmAdviseParams(const struct ur_enqueue_usm_advise_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_usm_fill_2d_params_t struct
@@ -1984,7 +1985,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueUsmAdviseParams(const struct u
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueUsmFill_2dParams(const struct ur_enqueue_usm_fill_2d_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueUsmFill_2dParams(const struct ur_enqueue_usm_fill_2d_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_usm_memcpy_2d_params_t struct
@@ -1992,7 +1993,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueUsmFill_2dParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueUsmMemcpy_2dParams(const struct ur_enqueue_usm_memcpy_2d_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueUsmMemcpy_2dParams(const struct ur_enqueue_usm_memcpy_2d_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_device_global_variable_write_params_t struct
@@ -2000,7 +2001,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueUsmMemcpy_2dParams(const struc
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueDeviceGlobalVariableWriteParams(const struct ur_enqueue_device_global_variable_write_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueDeviceGlobalVariableWriteParams(const struct ur_enqueue_device_global_variable_write_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_device_global_variable_read_params_t struct
@@ -2008,7 +2009,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueDeviceGlobalVariableWriteParam
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueDeviceGlobalVariableReadParams(const struct ur_enqueue_device_global_variable_read_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueDeviceGlobalVariableReadParams(const struct ur_enqueue_device_global_variable_read_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_read_host_pipe_params_t struct
@@ -2016,7 +2017,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueDeviceGlobalVariableReadParams
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueReadHostPipeParams(const struct ur_enqueue_read_host_pipe_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueReadHostPipeParams(const struct ur_enqueue_read_host_pipe_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_write_host_pipe_params_t struct
@@ -2024,7 +2025,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueReadHostPipeParams(const struc
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueWriteHostPipeParams(const struct ur_enqueue_write_host_pipe_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueWriteHostPipeParams(const struct ur_enqueue_write_host_pipe_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_kernel_launch_custom_exp_params_t struct
@@ -2032,7 +2033,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueWriteHostPipeParams(const stru
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueKernelLaunchCustomExpParams(const struct ur_enqueue_kernel_launch_custom_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueKernelLaunchCustomExpParams(const struct ur_enqueue_kernel_launch_custom_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_cooperative_kernel_launch_exp_params_t struct
@@ -2040,7 +2041,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueKernelLaunchCustomExpParams(co
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueCooperativeKernelLaunchExpParams(const struct ur_enqueue_cooperative_kernel_launch_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueCooperativeKernelLaunchExpParams(const struct ur_enqueue_cooperative_kernel_launch_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_timestamp_recording_exp_params_t struct
@@ -2048,7 +2049,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueCooperativeKernelLaunchExpPara
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueTimestampRecordingExpParams(const struct ur_enqueue_timestamp_recording_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueTimestampRecordingExpParams(const struct ur_enqueue_timestamp_recording_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_native_command_exp_params_t struct
@@ -2056,7 +2057,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueTimestampRecordingExpParams(co
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueNativeCommandExpParams(const struct ur_enqueue_native_command_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueNativeCommandExpParams(const struct ur_enqueue_native_command_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_bindless_images_unsampled_image_handle_destroy_exp_params_t struct
@@ -2064,7 +2065,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueNativeCommandExpParams(const s
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesUnsampledImageHandleDestroyExpParams(const struct ur_bindless_images_unsampled_image_handle_destroy_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesUnsampledImageHandleDestroyExpParams(const struct ur_bindless_images_unsampled_image_handle_destroy_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_bindless_images_sampled_image_handle_destroy_exp_params_t struct
@@ -2072,7 +2073,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesUnsampledImageHandleDes
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesSampledImageHandleDestroyExpParams(const struct ur_bindless_images_sampled_image_handle_destroy_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesSampledImageHandleDestroyExpParams(const struct ur_bindless_images_sampled_image_handle_destroy_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_bindless_images_image_allocate_exp_params_t struct
@@ -2080,7 +2081,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesSampledImageHandleDestr
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesImageAllocateExpParams(const struct ur_bindless_images_image_allocate_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesImageAllocateExpParams(const struct ur_bindless_images_image_allocate_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_bindless_images_image_free_exp_params_t struct
@@ -2088,7 +2089,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesImageAllocateExpParams(
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesImageFreeExpParams(const struct ur_bindless_images_image_free_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesImageFreeExpParams(const struct ur_bindless_images_image_free_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_bindless_images_unsampled_image_create_exp_params_t struct
@@ -2096,7 +2097,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesImageFreeExpParams(cons
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesUnsampledImageCreateExpParams(const struct ur_bindless_images_unsampled_image_create_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesUnsampledImageCreateExpParams(const struct ur_bindless_images_unsampled_image_create_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_bindless_images_sampled_image_create_exp_params_t struct
@@ -2104,7 +2105,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesUnsampledImageCreateExp
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesSampledImageCreateExpParams(const struct ur_bindless_images_sampled_image_create_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesSampledImageCreateExpParams(const struct ur_bindless_images_sampled_image_create_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_bindless_images_image_copy_exp_params_t struct
@@ -2112,7 +2113,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesSampledImageCreateExpPa
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesImageCopyExpParams(const struct ur_bindless_images_image_copy_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesImageCopyExpParams(const struct ur_bindless_images_image_copy_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_bindless_images_image_get_info_exp_params_t struct
@@ -2120,7 +2121,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesImageCopyExpParams(cons
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesImageGetInfoExpParams(const struct ur_bindless_images_image_get_info_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesImageGetInfoExpParams(const struct ur_bindless_images_image_get_info_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_bindless_images_mipmap_get_level_exp_params_t struct
@@ -2128,7 +2129,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesImageGetInfoExpParams(c
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesMipmapGetLevelExpParams(const struct ur_bindless_images_mipmap_get_level_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesMipmapGetLevelExpParams(const struct ur_bindless_images_mipmap_get_level_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_bindless_images_mipmap_free_exp_params_t struct
@@ -2136,7 +2137,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesMipmapGetLevelExpParams
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesMipmapFreeExpParams(const struct ur_bindless_images_mipmap_free_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesMipmapFreeExpParams(const struct ur_bindless_images_mipmap_free_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_bindless_images_import_external_memory_exp_params_t struct
@@ -2144,7 +2145,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesMipmapFreeExpParams(con
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesImportExternalMemoryExpParams(const struct ur_bindless_images_import_external_memory_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesImportExternalMemoryExpParams(const struct ur_bindless_images_import_external_memory_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_bindless_images_map_external_array_exp_params_t struct
@@ -2152,7 +2153,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesImportExternalMemoryExp
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesMapExternalArrayExpParams(const struct ur_bindless_images_map_external_array_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesMapExternalArrayExpParams(const struct ur_bindless_images_map_external_array_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_bindless_images_map_external_linear_memory_exp_params_t struct
@@ -2160,7 +2161,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesMapExternalArrayExpPara
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesMapExternalLinearMemoryExpParams(const struct ur_bindless_images_map_external_linear_memory_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesMapExternalLinearMemoryExpParams(const struct ur_bindless_images_map_external_linear_memory_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_bindless_images_release_external_memory_exp_params_t struct
@@ -2168,7 +2169,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesMapExternalLinearMemory
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesReleaseExternalMemoryExpParams(const struct ur_bindless_images_release_external_memory_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesReleaseExternalMemoryExpParams(const struct ur_bindless_images_release_external_memory_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_bindless_images_import_external_semaphore_exp_params_t struct
@@ -2176,7 +2177,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesReleaseExternalMemoryEx
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesImportExternalSemaphoreExpParams(const struct ur_bindless_images_import_external_semaphore_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesImportExternalSemaphoreExpParams(const struct ur_bindless_images_import_external_semaphore_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_bindless_images_release_external_semaphore_exp_params_t struct
@@ -2184,7 +2185,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesImportExternalSemaphore
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesReleaseExternalSemaphoreExpParams(const struct ur_bindless_images_release_external_semaphore_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesReleaseExternalSemaphoreExpParams(const struct ur_bindless_images_release_external_semaphore_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_bindless_images_wait_external_semaphore_exp_params_t struct
@@ -2192,7 +2193,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesReleaseExternalSemaphor
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesWaitExternalSemaphoreExpParams(const struct ur_bindless_images_wait_external_semaphore_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesWaitExternalSemaphoreExpParams(const struct ur_bindless_images_wait_external_semaphore_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_bindless_images_signal_external_semaphore_exp_params_t struct
@@ -2200,7 +2201,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesWaitExternalSemaphoreEx
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesSignalExternalSemaphoreExpParams(const struct ur_bindless_images_signal_external_semaphore_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesSignalExternalSemaphoreExpParams(const struct ur_bindless_images_signal_external_semaphore_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_host_alloc_params_t struct
@@ -2208,7 +2209,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintBindlessImagesSignalExternalSemaphore
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmHostAllocParams(const struct ur_usm_host_alloc_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmHostAllocParams(const struct ur_usm_host_alloc_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_device_alloc_params_t struct
@@ -2216,7 +2217,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmHostAllocParams(const struct ur_us
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmDeviceAllocParams(const struct ur_usm_device_alloc_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmDeviceAllocParams(const struct ur_usm_device_alloc_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_shared_alloc_params_t struct
@@ -2224,7 +2225,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmDeviceAllocParams(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmSharedAllocParams(const struct ur_usm_shared_alloc_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmSharedAllocParams(const struct ur_usm_shared_alloc_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_free_params_t struct
@@ -2232,7 +2233,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmSharedAllocParams(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmFreeParams(const struct ur_usm_free_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmFreeParams(const struct ur_usm_free_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_get_mem_alloc_info_params_t struct
@@ -2240,7 +2241,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmFreeParams(const struct ur_usm_fre
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmGetMemAllocInfoParams(const struct ur_usm_get_mem_alloc_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmGetMemAllocInfoParams(const struct ur_usm_get_mem_alloc_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_pool_create_params_t struct
@@ -2248,7 +2249,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmGetMemAllocInfoParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolCreateParams(const struct ur_usm_pool_create_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolCreateParams(const struct ur_usm_pool_create_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_pool_retain_params_t struct
@@ -2256,7 +2257,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolCreateParams(const struct ur_u
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolRetainParams(const struct ur_usm_pool_retain_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolRetainParams(const struct ur_usm_pool_retain_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_pool_release_params_t struct
@@ -2264,7 +2265,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolRetainParams(const struct ur_u
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolReleaseParams(const struct ur_usm_pool_release_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolReleaseParams(const struct ur_usm_pool_release_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_pool_get_info_params_t struct
@@ -2272,7 +2273,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolReleaseParams(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolGetInfoParams(const struct ur_usm_pool_get_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolGetInfoParams(const struct ur_usm_pool_get_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_pitched_alloc_exp_params_t struct
@@ -2280,7 +2281,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPoolGetInfoParams(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPitchedAllocExpParams(const struct ur_usm_pitched_alloc_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPitchedAllocExpParams(const struct ur_usm_pitched_alloc_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_import_exp_params_t struct
@@ -2288,7 +2289,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmPitchedAllocExpParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmImportExpParams(const struct ur_usm_import_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmImportExpParams(const struct ur_usm_import_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_release_exp_params_t struct
@@ -2296,7 +2297,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmImportExpParams(const struct ur_us
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmReleaseExpParams(const struct ur_usm_release_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmReleaseExpParams(const struct ur_usm_release_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_create_exp_params_t struct
@@ -2304,7 +2305,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmReleaseExpParams(const struct ur_u
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferCreateExpParams(const struct ur_command_buffer_create_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferCreateExpParams(const struct ur_command_buffer_create_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_retain_exp_params_t struct
@@ -2312,7 +2313,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferCreateExpParams(const st
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferRetainExpParams(const struct ur_command_buffer_retain_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferRetainExpParams(const struct ur_command_buffer_retain_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_release_exp_params_t struct
@@ -2320,7 +2321,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferRetainExpParams(const st
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferReleaseExpParams(const struct ur_command_buffer_release_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferReleaseExpParams(const struct ur_command_buffer_release_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_finalize_exp_params_t struct
@@ -2328,7 +2329,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferReleaseExpParams(const s
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferFinalizeExpParams(const struct ur_command_buffer_finalize_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferFinalizeExpParams(const struct ur_command_buffer_finalize_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_append_kernel_launch_exp_params_t struct
@@ -2336,7 +2337,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferFinalizeExpParams(const
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendKernelLaunchExpParams(const struct ur_command_buffer_append_kernel_launch_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendKernelLaunchExpParams(const struct ur_command_buffer_append_kernel_launch_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_append_usm_memcpy_exp_params_t struct
@@ -2344,7 +2345,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendKernelLaunchExpPar
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendUsmMemcpyExpParams(const struct ur_command_buffer_append_usm_memcpy_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendUsmMemcpyExpParams(const struct ur_command_buffer_append_usm_memcpy_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_append_usm_fill_exp_params_t struct
@@ -2352,7 +2353,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendUsmMemcpyExpParams
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendUsmFillExpParams(const struct ur_command_buffer_append_usm_fill_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendUsmFillExpParams(const struct ur_command_buffer_append_usm_fill_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_append_mem_buffer_copy_exp_params_t struct
@@ -2360,7 +2361,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendUsmFillExpParams(c
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferCopyExpParams(const struct ur_command_buffer_append_mem_buffer_copy_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferCopyExpParams(const struct ur_command_buffer_append_mem_buffer_copy_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_append_mem_buffer_write_exp_params_t struct
@@ -2368,7 +2369,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferCopyExpPa
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferWriteExpParams(const struct ur_command_buffer_append_mem_buffer_write_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferWriteExpParams(const struct ur_command_buffer_append_mem_buffer_write_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_append_mem_buffer_read_exp_params_t struct
@@ -2376,7 +2377,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferWriteExpP
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferReadExpParams(const struct ur_command_buffer_append_mem_buffer_read_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferReadExpParams(const struct ur_command_buffer_append_mem_buffer_read_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_append_mem_buffer_copy_rect_exp_params_t struct
@@ -2384,7 +2385,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferReadExpPa
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferCopyRectExpParams(const struct ur_command_buffer_append_mem_buffer_copy_rect_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferCopyRectExpParams(const struct ur_command_buffer_append_mem_buffer_copy_rect_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_append_mem_buffer_write_rect_exp_params_t struct
@@ -2392,7 +2393,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferCopyRectE
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferWriteRectExpParams(const struct ur_command_buffer_append_mem_buffer_write_rect_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferWriteRectExpParams(const struct ur_command_buffer_append_mem_buffer_write_rect_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_append_mem_buffer_read_rect_exp_params_t struct
@@ -2400,7 +2401,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferWriteRect
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferReadRectExpParams(const struct ur_command_buffer_append_mem_buffer_read_rect_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferReadRectExpParams(const struct ur_command_buffer_append_mem_buffer_read_rect_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_append_mem_buffer_fill_exp_params_t struct
@@ -2408,7 +2409,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferReadRectE
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferFillExpParams(const struct ur_command_buffer_append_mem_buffer_fill_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferFillExpParams(const struct ur_command_buffer_append_mem_buffer_fill_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_append_usm_prefetch_exp_params_t struct
@@ -2416,7 +2417,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendMemBufferFillExpPa
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendUsmPrefetchExpParams(const struct ur_command_buffer_append_usm_prefetch_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendUsmPrefetchExpParams(const struct ur_command_buffer_append_usm_prefetch_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_append_usm_advise_exp_params_t struct
@@ -2424,7 +2425,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendUsmPrefetchExpPara
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendUsmAdviseExpParams(const struct ur_command_buffer_append_usm_advise_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendUsmAdviseExpParams(const struct ur_command_buffer_append_usm_advise_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_enqueue_exp_params_t struct
@@ -2432,7 +2433,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferAppendUsmAdviseExpParams
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferEnqueueExpParams(const struct ur_command_buffer_enqueue_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferEnqueueExpParams(const struct ur_command_buffer_enqueue_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_retain_command_exp_params_t struct
@@ -2440,7 +2441,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferEnqueueExpParams(const s
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferRetainCommandExpParams(const struct ur_command_buffer_retain_command_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferRetainCommandExpParams(const struct ur_command_buffer_retain_command_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_release_command_exp_params_t struct
@@ -2448,7 +2449,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferRetainCommandExpParams(c
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferReleaseCommandExpParams(const struct ur_command_buffer_release_command_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferReleaseCommandExpParams(const struct ur_command_buffer_release_command_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_update_kernel_launch_exp_params_t struct
@@ -2456,7 +2457,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferReleaseCommandExpParams(
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferUpdateKernelLaunchExpParams(const struct ur_command_buffer_update_kernel_launch_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferUpdateKernelLaunchExpParams(const struct ur_command_buffer_update_kernel_launch_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_update_signal_event_exp_params_t struct
@@ -2464,7 +2465,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferUpdateKernelLaunchExpPar
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferUpdateSignalEventExpParams(const struct ur_command_buffer_update_signal_event_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferUpdateSignalEventExpParams(const struct ur_command_buffer_update_signal_event_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_update_wait_events_exp_params_t struct
@@ -2472,7 +2473,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferUpdateSignalEventExpPara
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferUpdateWaitEventsExpParams(const struct ur_command_buffer_update_wait_events_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferUpdateWaitEventsExpParams(const struct ur_command_buffer_update_wait_events_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_get_info_exp_params_t struct
@@ -2480,7 +2481,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferUpdateWaitEventsExpParam
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferGetInfoExpParams(const struct ur_command_buffer_get_info_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferGetInfoExpParams(const struct ur_command_buffer_get_info_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_command_buffer_command_get_info_exp_params_t struct
@@ -2488,7 +2489,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferGetInfoExpParams(const s
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferCommandGetInfoExpParams(const struct ur_command_buffer_command_get_info_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferCommandGetInfoExpParams(const struct ur_command_buffer_command_get_info_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_p2p_enable_peer_access_exp_params_t struct
@@ -2496,7 +2497,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintCommandBufferCommandGetInfoExpParams(
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmP2pEnablePeerAccessExpParams(const struct ur_usm_p2p_enable_peer_access_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmP2pEnablePeerAccessExpParams(const struct ur_usm_p2p_enable_peer_access_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_p2p_disable_peer_access_exp_params_t struct
@@ -2504,7 +2505,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmP2pEnablePeerAccessExpParams(const
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmP2pDisablePeerAccessExpParams(const struct ur_usm_p2p_disable_peer_access_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmP2pDisablePeerAccessExpParams(const struct ur_usm_p2p_disable_peer_access_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_usm_p2p_peer_access_get_info_exp_params_t struct
@@ -2512,7 +2513,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmP2pDisablePeerAccessExpParams(cons
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmP2pPeerAccessGetInfoExpParams(const struct ur_usm_p2p_peer_access_get_info_exp_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmP2pPeerAccessGetInfoExpParams(const struct ur_usm_p2p_peer_access_get_info_exp_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_loader_init_params_t struct
@@ -2520,7 +2521,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintUsmP2pPeerAccessGetInfoExpParams(cons
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderInitParams(const struct ur_loader_init_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderInitParams(const struct ur_loader_init_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_loader_tear_down_params_t struct
@@ -2528,7 +2529,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderInitParams(const struct ur_load
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderTearDownParams(const struct ur_loader_tear_down_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderTearDownParams(const struct ur_loader_tear_down_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_virtual_mem_granularity_get_info_params_t struct
@@ -2536,7 +2537,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintLoaderTearDownParams(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemGranularityGetInfoParams(const struct ur_virtual_mem_granularity_get_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemGranularityGetInfoParams(const struct ur_virtual_mem_granularity_get_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_virtual_mem_reserve_params_t struct
@@ -2544,7 +2545,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemGranularityGetInfoParams(co
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemReserveParams(const struct ur_virtual_mem_reserve_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemReserveParams(const struct ur_virtual_mem_reserve_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_virtual_mem_free_params_t struct
@@ -2552,7 +2553,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemReserveParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemFreeParams(const struct ur_virtual_mem_free_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemFreeParams(const struct ur_virtual_mem_free_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_virtual_mem_map_params_t struct
@@ -2560,7 +2561,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemFreeParams(const struct ur_
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemMapParams(const struct ur_virtual_mem_map_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemMapParams(const struct ur_virtual_mem_map_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_virtual_mem_unmap_params_t struct
@@ -2568,7 +2569,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemMapParams(const struct ur_v
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemUnmapParams(const struct ur_virtual_mem_unmap_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemUnmapParams(const struct ur_virtual_mem_unmap_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_virtual_mem_set_access_params_t struct
@@ -2576,7 +2577,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemUnmapParams(const struct ur
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemSetAccessParams(const struct ur_virtual_mem_set_access_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemSetAccessParams(const struct ur_virtual_mem_set_access_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_virtual_mem_get_info_params_t struct
@@ -2584,7 +2585,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemSetAccessParams(const struc
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemGetInfoParams(const struct ur_virtual_mem_get_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemGetInfoParams(const struct ur_virtual_mem_get_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_get_params_t struct
@@ -2592,7 +2593,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintVirtualMemGetInfoParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceGetParams(const struct ur_device_get_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceGetParams(const struct ur_device_get_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_get_selected_params_t struct
@@ -2600,7 +2601,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceGetParams(const struct ur_devic
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceGetSelectedParams(const struct ur_device_get_selected_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceGetSelectedParams(const struct ur_device_get_selected_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_get_info_params_t struct
@@ -2608,7 +2609,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceGetSelectedParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceGetInfoParams(const struct ur_device_get_info_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceGetInfoParams(const struct ur_device_get_info_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_retain_params_t struct
@@ -2616,7 +2617,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceGetInfoParams(const struct ur_d
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceRetainParams(const struct ur_device_retain_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceRetainParams(const struct ur_device_retain_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_release_params_t struct
@@ -2624,7 +2625,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceRetainParams(const struct ur_de
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceReleaseParams(const struct ur_device_release_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceReleaseParams(const struct ur_device_release_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_partition_params_t struct
@@ -2632,7 +2633,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceReleaseParams(const struct ur_d
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDevicePartitionParams(const struct ur_device_partition_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDevicePartitionParams(const struct ur_device_partition_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_select_binary_params_t struct
@@ -2640,7 +2641,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDevicePartitionParams(const struct ur
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceSelectBinaryParams(const struct ur_device_select_binary_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceSelectBinaryParams(const struct ur_device_select_binary_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_get_native_handle_params_t struct
@@ -2648,7 +2649,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceSelectBinaryParams(const struct
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceGetNativeHandleParams(const struct ur_device_get_native_handle_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceGetNativeHandleParams(const struct ur_device_get_native_handle_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_create_with_native_handle_params_t struct
@@ -2656,7 +2657,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceGetNativeHandleParams(const str
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceCreateWithNativeHandleParams(const struct ur_device_create_with_native_handle_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceCreateWithNativeHandleParams(const struct ur_device_create_with_native_handle_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_device_get_global_timestamps_params_t struct
@@ -2664,7 +2665,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceCreateWithNativeHandleParams(co
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceGetGlobalTimestampsParams(const struct ur_device_get_global_timestamps_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintDeviceGetGlobalTimestampsParams(const struct ur_device_get_global_timestamps_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
+
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print function parameters
diff --git a/include/ur_print.hpp b/include/ur_print.hpp
index a908fd9275..437703c945 100644
--- a/include/ur_print.hpp
+++ b/include/ur_print.hpp
@@ -14,17981 +14,24480 @@
 #define UR_PRINT_HPP 1
 
 #include "ur_api.h"
-#include <bitset>
 #include <ostream>
+#include <bitset>
 
-namespace ur::details {
-template <typename T>
-struct is_handle : std::false_type {};
-template <>
-struct is_handle<ur_loader_config_handle_t> : std::true_type {};
-template <>
-struct is_handle<ur_adapter_handle_t> : std::true_type {};
-template <>
-struct is_handle<ur_platform_handle_t> : std::true_type {};
-template <>
-struct is_handle<ur_device_handle_t> : std::true_type {};
-template <>
-struct is_handle<ur_context_handle_t> : std::true_type {};
-template <>
-struct is_handle<ur_event_handle_t> : std::true_type {};
-template <>
-struct is_handle<ur_program_handle_t> : std::true_type {};
-template <>
-struct is_handle<ur_kernel_handle_t> : std::true_type {};
-template <>
-struct is_handle<ur_queue_handle_t> : std::true_type {};
-template <>
-struct is_handle<ur_sampler_handle_t> : std::true_type {};
-template <>
-struct is_handle<ur_mem_handle_t> : std::true_type {};
-template <>
-struct is_handle<ur_physical_mem_handle_t> : std::true_type {};
-template <>
-struct is_handle<ur_usm_pool_handle_t> : std::true_type {};
-template <>
-struct is_handle<ur_exp_external_mem_handle_t> : std::true_type {};
-template <>
-struct is_handle<ur_exp_external_semaphore_handle_t> : std::true_type {};
-template <>
-struct is_handle<ur_exp_win32_handle_t> : std::true_type {};
-template <>
-struct is_handle<ur_exp_command_buffer_handle_t> : std::true_type {};
-template <>
-struct is_handle<ur_exp_command_buffer_command_handle_t> : std::true_type {};
-template <typename T>
-inline constexpr bool is_handle_v = is_handle<T>::value;
-template <typename T>
-inline ur_result_t printPtr(std::ostream &os, const T *ptr);
-template <typename T>
-inline ur_result_t printFlag(std::ostream &os, uint32_t flag);
-template <typename T>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, T value, size_t size);
-
-inline ur_result_t printStruct(std::ostream &os, const void *ptr);
-
-template <>
-inline ur_result_t printFlag<ur_device_init_flag_t>(std::ostream &os, uint32_t flag);
-
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_loader_config_info_t value, size_t size);
-
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_adapter_info_t value, size_t size);
-
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_platform_info_t value, size_t size);
-
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_device_info_t value, size_t size);
 
-template <>
-inline ur_result_t printFlag<ur_device_affinity_domain_flag_t>(std::ostream &os, uint32_t flag);
 
-inline ur_result_t printUnion(
-    std::ostream &os,
-    const union ur_device_partition_value_t params,
-    const enum ur_device_partition_t tag);
 
-template <>
-inline ur_result_t printFlag<ur_device_fp_capability_flag_t>(std::ostream &os, uint32_t flag);
 
-template <>
-inline ur_result_t printFlag<ur_device_exec_capability_flag_t>(std::ostream &os, uint32_t flag);
 
-template <>
-inline ur_result_t printFlag<ur_memory_order_capability_flag_t>(std::ostream &os, uint32_t flag);
 
-template <>
-inline ur_result_t printFlag<ur_memory_scope_capability_flag_t>(std::ostream &os, uint32_t flag);
+namespace ur::details {
+template <typename T> struct is_handle : std::false_type {};
+template <> struct is_handle<ur_loader_config_handle_t> : std::true_type {};
+template <> struct is_handle<ur_adapter_handle_t> : std::true_type {};
+template <> struct is_handle<ur_platform_handle_t> : std::true_type {};
+template <> struct is_handle<ur_device_handle_t> : std::true_type {};
+template <> struct is_handle<ur_context_handle_t> : std::true_type {};
+template <> struct is_handle<ur_event_handle_t> : std::true_type {};
+template <> struct is_handle<ur_program_handle_t> : std::true_type {};
+template <> struct is_handle<ur_kernel_handle_t> : std::true_type {};
+template <> struct is_handle<ur_queue_handle_t> : std::true_type {};
+template <> struct is_handle<ur_sampler_handle_t> : std::true_type {};
+template <> struct is_handle<ur_mem_handle_t> : std::true_type {};
+template <> struct is_handle<ur_physical_mem_handle_t> : std::true_type {};
+template <> struct is_handle<ur_usm_pool_handle_t> : std::true_type {};
+template <> struct is_handle<ur_exp_external_mem_handle_t> : std::true_type {};
+template <> struct is_handle<ur_exp_external_semaphore_handle_t> : std::true_type {};
+template <> struct is_handle<ur_exp_win32_handle_t> : std::true_type {};
+template <> struct is_handle<ur_exp_command_buffer_handle_t> : std::true_type {};
+template <> struct is_handle<ur_exp_command_buffer_command_handle_t> : std::true_type {};
+template <typename T>
+inline constexpr bool is_handle_v = is_handle<T>::value;
+template <typename T> inline ur_result_t printPtr(std::ostream &os, const T *ptr);
+template <typename T> inline ur_result_t printFlag(std::ostream &os, uint32_t flag);
+template <typename T> inline ur_result_t printTagged(std::ostream &os, const void *ptr, T value, size_t size);
 
-template <>
-inline ur_result_t printFlag<ur_device_usm_access_capability_flag_t>(std::ostream &os, uint32_t flag);
 
-template <>
-inline ur_result_t printFlag<ur_context_flag_t>(std::ostream &os, uint32_t flag);
 
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_context_info_t value, size_t size);
+    inline ur_result_t printStruct(std::ostream &os, const void *ptr);
 
-template <>
-inline ur_result_t printFlag<ur_mem_flag_t>(std::ostream &os, uint32_t flag);
 
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_mem_info_t value, size_t size);
 
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_image_info_t value, size_t size);
 
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_sampler_info_t value, size_t size);
 
-template <>
-inline ur_result_t printFlag<ur_usm_host_mem_flag_t>(std::ostream &os, uint32_t flag);
 
-template <>
-inline ur_result_t printFlag<ur_usm_device_mem_flag_t>(std::ostream &os, uint32_t flag);
 
-template <>
-inline ur_result_t printFlag<ur_usm_pool_flag_t>(std::ostream &os, uint32_t flag);
 
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_usm_alloc_info_t value, size_t size);
 
-template <>
-inline ur_result_t printFlag<ur_usm_advice_flag_t>(std::ostream &os, uint32_t flag);
 
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_usm_pool_info_t value, size_t size);
 
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_virtual_mem_granularity_info_t value, size_t size);
 
-template <>
-inline ur_result_t printFlag<ur_virtual_mem_access_flag_t>(std::ostream &os, uint32_t flag);
 
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_virtual_mem_info_t value, size_t size);
 
-template <>
-inline ur_result_t printFlag<ur_physical_mem_flag_t>(std::ostream &os, uint32_t flag);
 
-inline ur_result_t printUnion(
-    std::ostream &os,
-    const union ur_program_metadata_value_t params,
-    const enum ur_program_metadata_type_t tag);
 
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_program_info_t value, size_t size);
 
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_program_build_info_t value, size_t size);
 
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_kernel_info_t value, size_t size);
 
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_kernel_group_info_t value, size_t size);
 
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_kernel_sub_group_info_t value, size_t size);
 
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_kernel_exec_info_t value, size_t size);
 
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_queue_info_t value, size_t size);
 
-template <>
-inline ur_result_t printFlag<ur_queue_flag_t>(std::ostream &os, uint32_t flag);
 
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_event_info_t value, size_t size);
 
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_profiling_info_t value, size_t size);
 
-template <>
-inline ur_result_t printFlag<ur_map_flag_t>(std::ostream &os, uint32_t flag);
 
-template <>
-inline ur_result_t printFlag<ur_usm_migration_flag_t>(std::ostream &os, uint32_t flag);
 
-template <>
-inline ur_result_t printFlag<ur_exp_image_copy_flag_t>(std::ostream &os, uint32_t flag);
 
-template <>
-inline ur_result_t printFlag<ur_device_command_buffer_update_capability_flag_t>(std::ostream &os, uint32_t flag);
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_exp_command_buffer_info_t value, size_t size);
 
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_exp_command_buffer_command_info_t value, size_t size);
 
-inline ur_result_t printUnion(
-    std::ostream &os,
-    const union ur_exp_launch_property_value_t params,
-    const enum ur_exp_launch_property_id_t tag);
 
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_exp_peer_info_t value, size_t size);
 
-template <>
-inline ur_result_t printFlag<ur_exp_enqueue_native_command_flag_t>(std::ostream &os, uint32_t flag);
 
-} // namespace ur::details
 
-inline std::ostream &operator<<(std::ostream &os, enum ur_function_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_structure_type_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_result_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_base_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_base_desc_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_rect_offset_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_rect_region_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_init_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_loader_config_info_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_code_location_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_adapter_info_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_adapter_backend_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_platform_info_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_api_version_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_platform_native_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_platform_backend_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_device_binary_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_type_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_info_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_affinity_domain_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_partition_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_device_partition_property_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_device_partition_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_fp_capability_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_mem_cache_type_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_local_mem_type_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_exec_capability_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_device_native_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_memory_order_capability_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_memory_scope_capability_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_usm_access_capability_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_context_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_context_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_context_info_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_context_native_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_mem_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_mem_type_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_mem_info_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_image_channel_order_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_image_channel_type_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_image_info_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_image_format_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_image_desc_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_buffer_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_buffer_channel_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_buffer_alloc_location_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_buffer_region_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_buffer_create_type_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_native_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_sampler_filter_mode_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_sampler_addressing_mode_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_sampler_info_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_sampler_desc_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_sampler_native_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_usm_host_mem_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_usm_device_mem_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_usm_pool_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_usm_type_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_usm_alloc_info_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_usm_advice_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_desc_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_host_desc_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_device_desc_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_alloc_location_desc_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_pool_desc_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_pool_limits_desc_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_usm_pool_info_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_virtual_mem_granularity_info_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_virtual_mem_access_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_virtual_mem_info_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_physical_mem_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_physical_mem_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_program_metadata_type_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_metadata_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_program_info_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_program_build_status_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_program_binary_type_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_program_build_info_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_specialization_constant_info_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_native_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_arg_value_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_arg_local_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_kernel_info_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_kernel_group_info_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_kernel_sub_group_info_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_kernel_cache_config_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_kernel_exec_info_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_arg_pointer_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_exec_info_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_arg_sampler_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_arg_mem_obj_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_native_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_queue_info_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_queue_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_index_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_native_desc_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_native_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_command_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_event_status_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_event_info_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_profiling_info_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_event_native_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_execution_info_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_map_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_usm_migration_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_exp_image_copy_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_exp_sampler_cubemap_filter_mode_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_exp_external_mem_type_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_exp_external_semaphore_type_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_file_descriptor_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_win32_handle_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_sampler_mip_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_sampler_addr_modes_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_sampler_cubemap_properties_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_external_mem_desc_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_external_semaphore_desc_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_image_copy_region_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_command_buffer_update_capability_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_exp_command_buffer_info_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_exp_command_buffer_command_info_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_command_buffer_desc_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_command_buffer_update_memobj_arg_desc_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_command_buffer_update_pointer_arg_desc_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_command_buffer_update_value_arg_desc_t params);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_command_buffer_update_kernel_launch_desc_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_exp_launch_property_id_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_launch_property_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_exp_peer_info_t value);
-inline std::ostream &operator<<(std::ostream &os, enum ur_exp_enqueue_native_command_flag_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_enqueue_native_command_properties_t params);
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_function_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_function_t value) {
-    switch (value) {
-    case UR_FUNCTION_CONTEXT_CREATE:
-        os << "UR_FUNCTION_CONTEXT_CREATE";
-        break;
-    case UR_FUNCTION_CONTEXT_RETAIN:
-        os << "UR_FUNCTION_CONTEXT_RETAIN";
-        break;
-    case UR_FUNCTION_CONTEXT_RELEASE:
-        os << "UR_FUNCTION_CONTEXT_RELEASE";
-        break;
-    case UR_FUNCTION_CONTEXT_GET_INFO:
-        os << "UR_FUNCTION_CONTEXT_GET_INFO";
-        break;
-    case UR_FUNCTION_CONTEXT_GET_NATIVE_HANDLE:
-        os << "UR_FUNCTION_CONTEXT_GET_NATIVE_HANDLE";
-        break;
-    case UR_FUNCTION_CONTEXT_CREATE_WITH_NATIVE_HANDLE:
-        os << "UR_FUNCTION_CONTEXT_CREATE_WITH_NATIVE_HANDLE";
-        break;
-    case UR_FUNCTION_CONTEXT_SET_EXTENDED_DELETER:
-        os << "UR_FUNCTION_CONTEXT_SET_EXTENDED_DELETER";
-        break;
-    case UR_FUNCTION_DEVICE_GET:
-        os << "UR_FUNCTION_DEVICE_GET";
-        break;
-    case UR_FUNCTION_DEVICE_GET_INFO:
-        os << "UR_FUNCTION_DEVICE_GET_INFO";
-        break;
-    case UR_FUNCTION_DEVICE_RETAIN:
-        os << "UR_FUNCTION_DEVICE_RETAIN";
-        break;
-    case UR_FUNCTION_DEVICE_RELEASE:
-        os << "UR_FUNCTION_DEVICE_RELEASE";
-        break;
-    case UR_FUNCTION_DEVICE_PARTITION:
-        os << "UR_FUNCTION_DEVICE_PARTITION";
-        break;
-    case UR_FUNCTION_DEVICE_SELECT_BINARY:
-        os << "UR_FUNCTION_DEVICE_SELECT_BINARY";
-        break;
-    case UR_FUNCTION_DEVICE_GET_NATIVE_HANDLE:
-        os << "UR_FUNCTION_DEVICE_GET_NATIVE_HANDLE";
-        break;
-    case UR_FUNCTION_DEVICE_CREATE_WITH_NATIVE_HANDLE:
-        os << "UR_FUNCTION_DEVICE_CREATE_WITH_NATIVE_HANDLE";
-        break;
-    case UR_FUNCTION_DEVICE_GET_GLOBAL_TIMESTAMPS:
-        os << "UR_FUNCTION_DEVICE_GET_GLOBAL_TIMESTAMPS";
-        break;
-    case UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH:
-        os << "UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH";
-        break;
-    case UR_FUNCTION_ENQUEUE_EVENTS_WAIT:
-        os << "UR_FUNCTION_ENQUEUE_EVENTS_WAIT";
-        break;
-    case UR_FUNCTION_ENQUEUE_EVENTS_WAIT_WITH_BARRIER:
-        os << "UR_FUNCTION_ENQUEUE_EVENTS_WAIT_WITH_BARRIER";
-        break;
-    case UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ:
-        os << "UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ";
-        break;
-    case UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE:
-        os << "UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE";
-        break;
-    case UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ_RECT:
-        os << "UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ_RECT";
-        break;
-    case UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE_RECT:
-        os << "UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE_RECT";
-        break;
-    case UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY:
-        os << "UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY";
-        break;
-    case UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY_RECT:
-        os << "UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY_RECT";
-        break;
-    case UR_FUNCTION_ENQUEUE_MEM_BUFFER_FILL:
-        os << "UR_FUNCTION_ENQUEUE_MEM_BUFFER_FILL";
-        break;
-    case UR_FUNCTION_ENQUEUE_MEM_IMAGE_READ:
-        os << "UR_FUNCTION_ENQUEUE_MEM_IMAGE_READ";
-        break;
-    case UR_FUNCTION_ENQUEUE_MEM_IMAGE_WRITE:
-        os << "UR_FUNCTION_ENQUEUE_MEM_IMAGE_WRITE";
-        break;
-    case UR_FUNCTION_ENQUEUE_MEM_IMAGE_COPY:
-        os << "UR_FUNCTION_ENQUEUE_MEM_IMAGE_COPY";
-        break;
-    case UR_FUNCTION_ENQUEUE_MEM_BUFFER_MAP:
-        os << "UR_FUNCTION_ENQUEUE_MEM_BUFFER_MAP";
-        break;
-    case UR_FUNCTION_ENQUEUE_MEM_UNMAP:
-        os << "UR_FUNCTION_ENQUEUE_MEM_UNMAP";
-        break;
-    case UR_FUNCTION_ENQUEUE_USM_FILL:
-        os << "UR_FUNCTION_ENQUEUE_USM_FILL";
-        break;
-    case UR_FUNCTION_ENQUEUE_USM_MEMCPY:
-        os << "UR_FUNCTION_ENQUEUE_USM_MEMCPY";
-        break;
-    case UR_FUNCTION_ENQUEUE_USM_PREFETCH:
-        os << "UR_FUNCTION_ENQUEUE_USM_PREFETCH";
-        break;
-    case UR_FUNCTION_ENQUEUE_USM_ADVISE:
-        os << "UR_FUNCTION_ENQUEUE_USM_ADVISE";
-        break;
-    case UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_WRITE:
-        os << "UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_WRITE";
-        break;
-    case UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_READ:
-        os << "UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_READ";
-        break;
-    case UR_FUNCTION_EVENT_GET_INFO:
-        os << "UR_FUNCTION_EVENT_GET_INFO";
-        break;
-    case UR_FUNCTION_EVENT_GET_PROFILING_INFO:
-        os << "UR_FUNCTION_EVENT_GET_PROFILING_INFO";
-        break;
-    case UR_FUNCTION_EVENT_WAIT:
-        os << "UR_FUNCTION_EVENT_WAIT";
-        break;
-    case UR_FUNCTION_EVENT_RETAIN:
-        os << "UR_FUNCTION_EVENT_RETAIN";
-        break;
-    case UR_FUNCTION_EVENT_RELEASE:
-        os << "UR_FUNCTION_EVENT_RELEASE";
-        break;
-    case UR_FUNCTION_EVENT_GET_NATIVE_HANDLE:
-        os << "UR_FUNCTION_EVENT_GET_NATIVE_HANDLE";
-        break;
-    case UR_FUNCTION_EVENT_CREATE_WITH_NATIVE_HANDLE:
-        os << "UR_FUNCTION_EVENT_CREATE_WITH_NATIVE_HANDLE";
-        break;
-    case UR_FUNCTION_EVENT_SET_CALLBACK:
-        os << "UR_FUNCTION_EVENT_SET_CALLBACK";
-        break;
-    case UR_FUNCTION_KERNEL_CREATE:
-        os << "UR_FUNCTION_KERNEL_CREATE";
-        break;
-    case UR_FUNCTION_KERNEL_SET_ARG_VALUE:
-        os << "UR_FUNCTION_KERNEL_SET_ARG_VALUE";
-        break;
-    case UR_FUNCTION_KERNEL_SET_ARG_LOCAL:
-        os << "UR_FUNCTION_KERNEL_SET_ARG_LOCAL";
-        break;
-    case UR_FUNCTION_KERNEL_GET_INFO:
-        os << "UR_FUNCTION_KERNEL_GET_INFO";
-        break;
-    case UR_FUNCTION_KERNEL_GET_GROUP_INFO:
-        os << "UR_FUNCTION_KERNEL_GET_GROUP_INFO";
-        break;
-    case UR_FUNCTION_KERNEL_GET_SUB_GROUP_INFO:
-        os << "UR_FUNCTION_KERNEL_GET_SUB_GROUP_INFO";
-        break;
-    case UR_FUNCTION_KERNEL_RETAIN:
-        os << "UR_FUNCTION_KERNEL_RETAIN";
-        break;
-    case UR_FUNCTION_KERNEL_RELEASE:
-        os << "UR_FUNCTION_KERNEL_RELEASE";
-        break;
-    case UR_FUNCTION_KERNEL_SET_ARG_POINTER:
-        os << "UR_FUNCTION_KERNEL_SET_ARG_POINTER";
-        break;
-    case UR_FUNCTION_KERNEL_SET_EXEC_INFO:
-        os << "UR_FUNCTION_KERNEL_SET_EXEC_INFO";
-        break;
-    case UR_FUNCTION_KERNEL_SET_ARG_SAMPLER:
-        os << "UR_FUNCTION_KERNEL_SET_ARG_SAMPLER";
-        break;
-    case UR_FUNCTION_KERNEL_SET_ARG_MEM_OBJ:
-        os << "UR_FUNCTION_KERNEL_SET_ARG_MEM_OBJ";
-        break;
-    case UR_FUNCTION_KERNEL_SET_SPECIALIZATION_CONSTANTS:
-        os << "UR_FUNCTION_KERNEL_SET_SPECIALIZATION_CONSTANTS";
-        break;
-    case UR_FUNCTION_KERNEL_GET_NATIVE_HANDLE:
-        os << "UR_FUNCTION_KERNEL_GET_NATIVE_HANDLE";
-        break;
-    case UR_FUNCTION_KERNEL_CREATE_WITH_NATIVE_HANDLE:
-        os << "UR_FUNCTION_KERNEL_CREATE_WITH_NATIVE_HANDLE";
-        break;
-    case UR_FUNCTION_MEM_IMAGE_CREATE:
-        os << "UR_FUNCTION_MEM_IMAGE_CREATE";
-        break;
-    case UR_FUNCTION_MEM_BUFFER_CREATE:
-        os << "UR_FUNCTION_MEM_BUFFER_CREATE";
-        break;
-    case UR_FUNCTION_MEM_RETAIN:
-        os << "UR_FUNCTION_MEM_RETAIN";
-        break;
-    case UR_FUNCTION_MEM_RELEASE:
-        os << "UR_FUNCTION_MEM_RELEASE";
-        break;
-    case UR_FUNCTION_MEM_BUFFER_PARTITION:
-        os << "UR_FUNCTION_MEM_BUFFER_PARTITION";
-        break;
-    case UR_FUNCTION_MEM_GET_NATIVE_HANDLE:
-        os << "UR_FUNCTION_MEM_GET_NATIVE_HANDLE";
-        break;
-    case UR_FUNCTION_ENQUEUE_READ_HOST_PIPE:
-        os << "UR_FUNCTION_ENQUEUE_READ_HOST_PIPE";
-        break;
-    case UR_FUNCTION_MEM_GET_INFO:
-        os << "UR_FUNCTION_MEM_GET_INFO";
-        break;
-    case UR_FUNCTION_MEM_IMAGE_GET_INFO:
-        os << "UR_FUNCTION_MEM_IMAGE_GET_INFO";
-        break;
-    case UR_FUNCTION_PLATFORM_GET:
-        os << "UR_FUNCTION_PLATFORM_GET";
-        break;
-    case UR_FUNCTION_PLATFORM_GET_INFO:
-        os << "UR_FUNCTION_PLATFORM_GET_INFO";
-        break;
-    case UR_FUNCTION_PLATFORM_GET_API_VERSION:
-        os << "UR_FUNCTION_PLATFORM_GET_API_VERSION";
-        break;
-    case UR_FUNCTION_PLATFORM_GET_NATIVE_HANDLE:
-        os << "UR_FUNCTION_PLATFORM_GET_NATIVE_HANDLE";
-        break;
-    case UR_FUNCTION_PLATFORM_CREATE_WITH_NATIVE_HANDLE:
-        os << "UR_FUNCTION_PLATFORM_CREATE_WITH_NATIVE_HANDLE";
-        break;
-    case UR_FUNCTION_PROGRAM_CREATE_WITH_IL:
-        os << "UR_FUNCTION_PROGRAM_CREATE_WITH_IL";
-        break;
-    case UR_FUNCTION_PROGRAM_CREATE_WITH_BINARY:
-        os << "UR_FUNCTION_PROGRAM_CREATE_WITH_BINARY";
-        break;
-    case UR_FUNCTION_PROGRAM_BUILD:
-        os << "UR_FUNCTION_PROGRAM_BUILD";
-        break;
-    case UR_FUNCTION_PROGRAM_COMPILE:
-        os << "UR_FUNCTION_PROGRAM_COMPILE";
-        break;
-    case UR_FUNCTION_PROGRAM_LINK:
-        os << "UR_FUNCTION_PROGRAM_LINK";
-        break;
-    case UR_FUNCTION_PROGRAM_RETAIN:
-        os << "UR_FUNCTION_PROGRAM_RETAIN";
-        break;
-    case UR_FUNCTION_PROGRAM_RELEASE:
-        os << "UR_FUNCTION_PROGRAM_RELEASE";
-        break;
-    case UR_FUNCTION_PROGRAM_GET_FUNCTION_POINTER:
-        os << "UR_FUNCTION_PROGRAM_GET_FUNCTION_POINTER";
-        break;
-    case UR_FUNCTION_PROGRAM_GET_INFO:
-        os << "UR_FUNCTION_PROGRAM_GET_INFO";
-        break;
-    case UR_FUNCTION_PROGRAM_GET_BUILD_INFO:
-        os << "UR_FUNCTION_PROGRAM_GET_BUILD_INFO";
-        break;
-    case UR_FUNCTION_PROGRAM_SET_SPECIALIZATION_CONSTANTS:
-        os << "UR_FUNCTION_PROGRAM_SET_SPECIALIZATION_CONSTANTS";
-        break;
-    case UR_FUNCTION_PROGRAM_GET_NATIVE_HANDLE:
-        os << "UR_FUNCTION_PROGRAM_GET_NATIVE_HANDLE";
-        break;
-    case UR_FUNCTION_PROGRAM_CREATE_WITH_NATIVE_HANDLE:
-        os << "UR_FUNCTION_PROGRAM_CREATE_WITH_NATIVE_HANDLE";
-        break;
-    case UR_FUNCTION_QUEUE_GET_INFO:
-        os << "UR_FUNCTION_QUEUE_GET_INFO";
-        break;
-    case UR_FUNCTION_QUEUE_CREATE:
-        os << "UR_FUNCTION_QUEUE_CREATE";
-        break;
-    case UR_FUNCTION_QUEUE_RETAIN:
-        os << "UR_FUNCTION_QUEUE_RETAIN";
-        break;
-    case UR_FUNCTION_QUEUE_RELEASE:
-        os << "UR_FUNCTION_QUEUE_RELEASE";
-        break;
-    case UR_FUNCTION_QUEUE_GET_NATIVE_HANDLE:
-        os << "UR_FUNCTION_QUEUE_GET_NATIVE_HANDLE";
-        break;
-    case UR_FUNCTION_QUEUE_CREATE_WITH_NATIVE_HANDLE:
-        os << "UR_FUNCTION_QUEUE_CREATE_WITH_NATIVE_HANDLE";
-        break;
-    case UR_FUNCTION_QUEUE_FINISH:
-        os << "UR_FUNCTION_QUEUE_FINISH";
-        break;
-    case UR_FUNCTION_QUEUE_FLUSH:
-        os << "UR_FUNCTION_QUEUE_FLUSH";
-        break;
-    case UR_FUNCTION_SAMPLER_CREATE:
-        os << "UR_FUNCTION_SAMPLER_CREATE";
-        break;
-    case UR_FUNCTION_SAMPLER_RETAIN:
-        os << "UR_FUNCTION_SAMPLER_RETAIN";
-        break;
-    case UR_FUNCTION_SAMPLER_RELEASE:
-        os << "UR_FUNCTION_SAMPLER_RELEASE";
-        break;
-    case UR_FUNCTION_SAMPLER_GET_INFO:
-        os << "UR_FUNCTION_SAMPLER_GET_INFO";
-        break;
-    case UR_FUNCTION_SAMPLER_GET_NATIVE_HANDLE:
-        os << "UR_FUNCTION_SAMPLER_GET_NATIVE_HANDLE";
-        break;
-    case UR_FUNCTION_SAMPLER_CREATE_WITH_NATIVE_HANDLE:
-        os << "UR_FUNCTION_SAMPLER_CREATE_WITH_NATIVE_HANDLE";
-        break;
-    case UR_FUNCTION_USM_HOST_ALLOC:
-        os << "UR_FUNCTION_USM_HOST_ALLOC";
-        break;
-    case UR_FUNCTION_USM_DEVICE_ALLOC:
-        os << "UR_FUNCTION_USM_DEVICE_ALLOC";
-        break;
-    case UR_FUNCTION_USM_SHARED_ALLOC:
-        os << "UR_FUNCTION_USM_SHARED_ALLOC";
-        break;
-    case UR_FUNCTION_USM_FREE:
-        os << "UR_FUNCTION_USM_FREE";
-        break;
-    case UR_FUNCTION_USM_GET_MEM_ALLOC_INFO:
-        os << "UR_FUNCTION_USM_GET_MEM_ALLOC_INFO";
-        break;
-    case UR_FUNCTION_USM_POOL_CREATE:
-        os << "UR_FUNCTION_USM_POOL_CREATE";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_CREATE_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_CREATE_EXP";
-        break;
-    case UR_FUNCTION_PLATFORM_GET_BACKEND_OPTION:
-        os << "UR_FUNCTION_PLATFORM_GET_BACKEND_OPTION";
-        break;
-    case UR_FUNCTION_MEM_BUFFER_CREATE_WITH_NATIVE_HANDLE:
-        os << "UR_FUNCTION_MEM_BUFFER_CREATE_WITH_NATIVE_HANDLE";
-        break;
-    case UR_FUNCTION_MEM_IMAGE_CREATE_WITH_NATIVE_HANDLE:
-        os << "UR_FUNCTION_MEM_IMAGE_CREATE_WITH_NATIVE_HANDLE";
-        break;
-    case UR_FUNCTION_ENQUEUE_WRITE_HOST_PIPE:
-        os << "UR_FUNCTION_ENQUEUE_WRITE_HOST_PIPE";
-        break;
-    case UR_FUNCTION_USM_POOL_RETAIN:
-        os << "UR_FUNCTION_USM_POOL_RETAIN";
-        break;
-    case UR_FUNCTION_USM_POOL_RELEASE:
-        os << "UR_FUNCTION_USM_POOL_RELEASE";
-        break;
-    case UR_FUNCTION_USM_POOL_GET_INFO:
-        os << "UR_FUNCTION_USM_POOL_GET_INFO";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_RETAIN_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_RETAIN_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_RELEASE_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_RELEASE_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_FINALIZE_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_FINALIZE_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_KERNEL_LAUNCH_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_KERNEL_LAUNCH_EXP";
-        break;
-    case UR_FUNCTION_USM_PITCHED_ALLOC_EXP:
-        os << "UR_FUNCTION_USM_PITCHED_ALLOC_EXP";
-        break;
-    case UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_HANDLE_DESTROY_EXP:
-        os << "UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_HANDLE_DESTROY_EXP";
-        break;
-    case UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_HANDLE_DESTROY_EXP:
-        os << "UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_HANDLE_DESTROY_EXP";
-        break;
-    case UR_FUNCTION_BINDLESS_IMAGES_IMAGE_ALLOCATE_EXP:
-        os << "UR_FUNCTION_BINDLESS_IMAGES_IMAGE_ALLOCATE_EXP";
-        break;
-    case UR_FUNCTION_BINDLESS_IMAGES_IMAGE_FREE_EXP:
-        os << "UR_FUNCTION_BINDLESS_IMAGES_IMAGE_FREE_EXP";
-        break;
-    case UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_CREATE_EXP:
-        os << "UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_CREATE_EXP";
-        break;
-    case UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_CREATE_EXP:
-        os << "UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_CREATE_EXP";
-        break;
-    case UR_FUNCTION_BINDLESS_IMAGES_IMAGE_COPY_EXP:
-        os << "UR_FUNCTION_BINDLESS_IMAGES_IMAGE_COPY_EXP";
-        break;
-    case UR_FUNCTION_BINDLESS_IMAGES_IMAGE_GET_INFO_EXP:
-        os << "UR_FUNCTION_BINDLESS_IMAGES_IMAGE_GET_INFO_EXP";
-        break;
-    case UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_GET_LEVEL_EXP:
-        os << "UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_GET_LEVEL_EXP";
-        break;
-    case UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_FREE_EXP:
-        os << "UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_FREE_EXP";
-        break;
-    case UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_ARRAY_EXP:
-        os << "UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_ARRAY_EXP";
-        break;
-    case UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_SEMAPHORE_EXP:
-        os << "UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_SEMAPHORE_EXP";
-        break;
-    case UR_FUNCTION_BINDLESS_IMAGES_WAIT_EXTERNAL_SEMAPHORE_EXP:
-        os << "UR_FUNCTION_BINDLESS_IMAGES_WAIT_EXTERNAL_SEMAPHORE_EXP";
-        break;
-    case UR_FUNCTION_BINDLESS_IMAGES_SIGNAL_EXTERNAL_SEMAPHORE_EXP:
-        os << "UR_FUNCTION_BINDLESS_IMAGES_SIGNAL_EXTERNAL_SEMAPHORE_EXP";
-        break;
-    case UR_FUNCTION_ENQUEUE_USM_FILL_2D:
-        os << "UR_FUNCTION_ENQUEUE_USM_FILL_2D";
-        break;
-    case UR_FUNCTION_ENQUEUE_USM_MEMCPY_2D:
-        os << "UR_FUNCTION_ENQUEUE_USM_MEMCPY_2D";
-        break;
-    case UR_FUNCTION_VIRTUAL_MEM_GRANULARITY_GET_INFO:
-        os << "UR_FUNCTION_VIRTUAL_MEM_GRANULARITY_GET_INFO";
-        break;
-    case UR_FUNCTION_VIRTUAL_MEM_RESERVE:
-        os << "UR_FUNCTION_VIRTUAL_MEM_RESERVE";
-        break;
-    case UR_FUNCTION_VIRTUAL_MEM_FREE:
-        os << "UR_FUNCTION_VIRTUAL_MEM_FREE";
-        break;
-    case UR_FUNCTION_VIRTUAL_MEM_MAP:
-        os << "UR_FUNCTION_VIRTUAL_MEM_MAP";
-        break;
-    case UR_FUNCTION_VIRTUAL_MEM_UNMAP:
-        os << "UR_FUNCTION_VIRTUAL_MEM_UNMAP";
-        break;
-    case UR_FUNCTION_VIRTUAL_MEM_SET_ACCESS:
-        os << "UR_FUNCTION_VIRTUAL_MEM_SET_ACCESS";
-        break;
-    case UR_FUNCTION_VIRTUAL_MEM_GET_INFO:
-        os << "UR_FUNCTION_VIRTUAL_MEM_GET_INFO";
-        break;
-    case UR_FUNCTION_PHYSICAL_MEM_CREATE:
-        os << "UR_FUNCTION_PHYSICAL_MEM_CREATE";
-        break;
-    case UR_FUNCTION_PHYSICAL_MEM_RETAIN:
-        os << "UR_FUNCTION_PHYSICAL_MEM_RETAIN";
-        break;
-    case UR_FUNCTION_PHYSICAL_MEM_RELEASE:
-        os << "UR_FUNCTION_PHYSICAL_MEM_RELEASE";
-        break;
-    case UR_FUNCTION_USM_IMPORT_EXP:
-        os << "UR_FUNCTION_USM_IMPORT_EXP";
-        break;
-    case UR_FUNCTION_USM_RELEASE_EXP:
-        os << "UR_FUNCTION_USM_RELEASE_EXP";
-        break;
-    case UR_FUNCTION_USM_P2P_ENABLE_PEER_ACCESS_EXP:
-        os << "UR_FUNCTION_USM_P2P_ENABLE_PEER_ACCESS_EXP";
-        break;
-    case UR_FUNCTION_USM_P2P_DISABLE_PEER_ACCESS_EXP:
-        os << "UR_FUNCTION_USM_P2P_DISABLE_PEER_ACCESS_EXP";
-        break;
-    case UR_FUNCTION_USM_P2P_PEER_ACCESS_GET_INFO_EXP:
-        os << "UR_FUNCTION_USM_P2P_PEER_ACCESS_GET_INFO_EXP";
-        break;
-    case UR_FUNCTION_LOADER_CONFIG_CREATE:
-        os << "UR_FUNCTION_LOADER_CONFIG_CREATE";
-        break;
-    case UR_FUNCTION_LOADER_CONFIG_RELEASE:
-        os << "UR_FUNCTION_LOADER_CONFIG_RELEASE";
-        break;
-    case UR_FUNCTION_LOADER_CONFIG_RETAIN:
-        os << "UR_FUNCTION_LOADER_CONFIG_RETAIN";
-        break;
-    case UR_FUNCTION_LOADER_CONFIG_GET_INFO:
-        os << "UR_FUNCTION_LOADER_CONFIG_GET_INFO";
-        break;
-    case UR_FUNCTION_LOADER_CONFIG_ENABLE_LAYER:
-        os << "UR_FUNCTION_LOADER_CONFIG_ENABLE_LAYER";
-        break;
-    case UR_FUNCTION_ADAPTER_RELEASE:
-        os << "UR_FUNCTION_ADAPTER_RELEASE";
-        break;
-    case UR_FUNCTION_ADAPTER_GET:
-        os << "UR_FUNCTION_ADAPTER_GET";
-        break;
-    case UR_FUNCTION_ADAPTER_RETAIN:
-        os << "UR_FUNCTION_ADAPTER_RETAIN";
-        break;
-    case UR_FUNCTION_ADAPTER_GET_LAST_ERROR:
-        os << "UR_FUNCTION_ADAPTER_GET_LAST_ERROR";
-        break;
-    case UR_FUNCTION_ADAPTER_GET_INFO:
-        os << "UR_FUNCTION_ADAPTER_GET_INFO";
-        break;
-    case UR_FUNCTION_PROGRAM_BUILD_EXP:
-        os << "UR_FUNCTION_PROGRAM_BUILD_EXP";
-        break;
-    case UR_FUNCTION_PROGRAM_COMPILE_EXP:
-        os << "UR_FUNCTION_PROGRAM_COMPILE_EXP";
-        break;
-    case UR_FUNCTION_PROGRAM_LINK_EXP:
-        os << "UR_FUNCTION_PROGRAM_LINK_EXP";
-        break;
-    case UR_FUNCTION_LOADER_CONFIG_SET_CODE_LOCATION_CALLBACK:
-        os << "UR_FUNCTION_LOADER_CONFIG_SET_CODE_LOCATION_CALLBACK";
-        break;
-    case UR_FUNCTION_LOADER_INIT:
-        os << "UR_FUNCTION_LOADER_INIT";
-        break;
-    case UR_FUNCTION_LOADER_TEAR_DOWN:
-        os << "UR_FUNCTION_LOADER_TEAR_DOWN";
-        break;
-    case UR_FUNCTION_ENQUEUE_COOPERATIVE_KERNEL_LAUNCH_EXP:
-        os << "UR_FUNCTION_ENQUEUE_COOPERATIVE_KERNEL_LAUNCH_EXP";
-        break;
-    case UR_FUNCTION_KERNEL_SUGGEST_MAX_COOPERATIVE_GROUP_COUNT_EXP:
-        os << "UR_FUNCTION_KERNEL_SUGGEST_MAX_COOPERATIVE_GROUP_COUNT_EXP";
-        break;
-    case UR_FUNCTION_PROGRAM_GET_GLOBAL_VARIABLE_POINTER:
-        os << "UR_FUNCTION_PROGRAM_GET_GLOBAL_VARIABLE_POINTER";
-        break;
-    case UR_FUNCTION_DEVICE_GET_SELECTED:
-        os << "UR_FUNCTION_DEVICE_GET_SELECTED";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_RETAIN_COMMAND_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_RETAIN_COMMAND_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_RELEASE_COMMAND_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_RELEASE_COMMAND_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_UPDATE_KERNEL_LAUNCH_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_UPDATE_KERNEL_LAUNCH_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_GET_INFO_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_GET_INFO_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_COMMAND_GET_INFO_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_COMMAND_GET_INFO_EXP";
-        break;
-    case UR_FUNCTION_ENQUEUE_TIMESTAMP_RECORDING_EXP:
-        os << "UR_FUNCTION_ENQUEUE_TIMESTAMP_RECORDING_EXP";
-        break;
-    case UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH_CUSTOM_EXP:
-        os << "UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH_CUSTOM_EXP";
-        break;
-    case UR_FUNCTION_KERNEL_GET_SUGGESTED_LOCAL_WORK_SIZE:
-        os << "UR_FUNCTION_KERNEL_GET_SUGGESTED_LOCAL_WORK_SIZE";
-        break;
-    case UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_MEMORY_EXP:
-        os << "UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_MEMORY_EXP";
-        break;
-    case UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_SEMAPHORE_EXP:
-        os << "UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_SEMAPHORE_EXP";
-        break;
-    case UR_FUNCTION_ENQUEUE_NATIVE_COMMAND_EXP:
-        os << "UR_FUNCTION_ENQUEUE_NATIVE_COMMAND_EXP";
-        break;
-    case UR_FUNCTION_LOADER_CONFIG_SET_MOCKING_ENABLED:
-        os << "UR_FUNCTION_LOADER_CONFIG_SET_MOCKING_ENABLED";
-        break;
-    case UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_MEMORY_EXP:
-        os << "UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_MEMORY_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_MEMCPY_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_MEMCPY_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_FILL_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_FILL_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_RECT_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_RECT_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_RECT_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_RECT_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_RECT_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_RECT_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_FILL_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_FILL_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_PREFETCH_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_PREFETCH_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_ADVISE_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_ADVISE_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_ENQUEUE_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_ENQUEUE_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_UPDATE_SIGNAL_EVENT_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_UPDATE_SIGNAL_EVENT_EXP";
-        break;
-    case UR_FUNCTION_COMMAND_BUFFER_UPDATE_WAIT_EVENTS_EXP:
-        os << "UR_FUNCTION_COMMAND_BUFFER_UPDATE_WAIT_EVENTS_EXP";
-        break;
-    case UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_LINEAR_MEMORY_EXP:
-        os << "UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_LINEAR_MEMORY_EXP";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_structure_type_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_structure_type_t value) {
-    switch (value) {
-    case UR_STRUCTURE_TYPE_CONTEXT_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_CONTEXT_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_IMAGE_DESC:
-        os << "UR_STRUCTURE_TYPE_IMAGE_DESC";
-        break;
-    case UR_STRUCTURE_TYPE_BUFFER_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_BUFFER_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_BUFFER_REGION:
-        os << "UR_STRUCTURE_TYPE_BUFFER_REGION";
-        break;
-    case UR_STRUCTURE_TYPE_BUFFER_CHANNEL_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_BUFFER_CHANNEL_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_BUFFER_ALLOC_LOCATION_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_BUFFER_ALLOC_LOCATION_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_USM_DESC:
-        os << "UR_STRUCTURE_TYPE_USM_DESC";
-        break;
-    case UR_STRUCTURE_TYPE_USM_HOST_DESC:
-        os << "UR_STRUCTURE_TYPE_USM_HOST_DESC";
-        break;
-    case UR_STRUCTURE_TYPE_USM_DEVICE_DESC:
-        os << "UR_STRUCTURE_TYPE_USM_DEVICE_DESC";
-        break;
-    case UR_STRUCTURE_TYPE_USM_POOL_DESC:
-        os << "UR_STRUCTURE_TYPE_USM_POOL_DESC";
-        break;
-    case UR_STRUCTURE_TYPE_USM_POOL_LIMITS_DESC:
-        os << "UR_STRUCTURE_TYPE_USM_POOL_LIMITS_DESC";
-        break;
-    case UR_STRUCTURE_TYPE_DEVICE_BINARY:
-        os << "UR_STRUCTURE_TYPE_DEVICE_BINARY";
-        break;
-    case UR_STRUCTURE_TYPE_SAMPLER_DESC:
-        os << "UR_STRUCTURE_TYPE_SAMPLER_DESC";
-        break;
-    case UR_STRUCTURE_TYPE_QUEUE_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_QUEUE_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_QUEUE_INDEX_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_QUEUE_INDEX_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_CONTEXT_NATIVE_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_CONTEXT_NATIVE_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_KERNEL_NATIVE_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_KERNEL_NATIVE_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_QUEUE_NATIVE_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_QUEUE_NATIVE_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_MEM_NATIVE_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_MEM_NATIVE_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_EVENT_NATIVE_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_EVENT_NATIVE_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_PLATFORM_NATIVE_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_PLATFORM_NATIVE_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_DEVICE_NATIVE_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_DEVICE_NATIVE_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_PROGRAM_NATIVE_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_PROGRAM_NATIVE_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_SAMPLER_NATIVE_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_SAMPLER_NATIVE_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_QUEUE_NATIVE_DESC:
-        os << "UR_STRUCTURE_TYPE_QUEUE_NATIVE_DESC";
-        break;
-    case UR_STRUCTURE_TYPE_DEVICE_PARTITION_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_DEVICE_PARTITION_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_KERNEL_ARG_MEM_OBJ_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_KERNEL_ARG_MEM_OBJ_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_PHYSICAL_MEM_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_PHYSICAL_MEM_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_KERNEL_ARG_POINTER_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_KERNEL_ARG_POINTER_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_KERNEL_ARG_SAMPLER_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_KERNEL_ARG_SAMPLER_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_KERNEL_EXEC_INFO_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_KERNEL_EXEC_INFO_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_KERNEL_ARG_VALUE_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_KERNEL_ARG_VALUE_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_KERNEL_ARG_LOCAL_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_KERNEL_ARG_LOCAL_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_USM_ALLOC_LOCATION_DESC:
-        os << "UR_STRUCTURE_TYPE_USM_ALLOC_LOCATION_DESC";
-        break;
-    case UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_DESC:
-        os << "UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_DESC";
-        break;
-    case UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_KERNEL_LAUNCH_DESC:
-        os << "UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_KERNEL_LAUNCH_DESC";
-        break;
-    case UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_MEMOBJ_ARG_DESC:
-        os << "UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_MEMOBJ_ARG_DESC";
-        break;
-    case UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_POINTER_ARG_DESC:
-        os << "UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_POINTER_ARG_DESC";
-        break;
-    case UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_VALUE_ARG_DESC:
-        os << "UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_VALUE_ARG_DESC";
-        break;
-    case UR_STRUCTURE_TYPE_EXP_SAMPLER_MIP_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_EXP_SAMPLER_MIP_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_EXP_EXTERNAL_MEM_DESC:
-        os << "UR_STRUCTURE_TYPE_EXP_EXTERNAL_MEM_DESC";
-        break;
-    case UR_STRUCTURE_TYPE_EXP_EXTERNAL_SEMAPHORE_DESC:
-        os << "UR_STRUCTURE_TYPE_EXP_EXTERNAL_SEMAPHORE_DESC";
-        break;
-    case UR_STRUCTURE_TYPE_EXP_FILE_DESCRIPTOR:
-        os << "UR_STRUCTURE_TYPE_EXP_FILE_DESCRIPTOR";
-        break;
-    case UR_STRUCTURE_TYPE_EXP_WIN32_HANDLE:
-        os << "UR_STRUCTURE_TYPE_EXP_WIN32_HANDLE";
-        break;
-    case UR_STRUCTURE_TYPE_EXP_SAMPLER_ADDR_MODES:
-        os << "UR_STRUCTURE_TYPE_EXP_SAMPLER_ADDR_MODES";
-        break;
-    case UR_STRUCTURE_TYPE_EXP_SAMPLER_CUBEMAP_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_EXP_SAMPLER_CUBEMAP_PROPERTIES";
-        break;
-    case UR_STRUCTURE_TYPE_EXP_IMAGE_COPY_REGION:
-        os << "UR_STRUCTURE_TYPE_EXP_IMAGE_COPY_REGION";
-        break;
-    case UR_STRUCTURE_TYPE_EXP_ENQUEUE_NATIVE_COMMAND_PROPERTIES:
-        os << "UR_STRUCTURE_TYPE_EXP_ENQUEUE_NATIVE_COMMAND_PROPERTIES";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_structure_type_t struct
-inline ur_result_t printStruct(std::ostream &os, const void *ptr) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
-
-    const enum ur_structure_type_t *value = (const enum ur_structure_type_t *)ptr;
-    switch (*value) {
-
-    case UR_STRUCTURE_TYPE_CONTEXT_PROPERTIES: {
-        const ur_context_properties_t *pstruct = (const ur_context_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_IMAGE_DESC: {
-        const ur_image_desc_t *pstruct = (const ur_image_desc_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_BUFFER_PROPERTIES: {
-        const ur_buffer_properties_t *pstruct = (const ur_buffer_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_BUFFER_REGION: {
-        const ur_buffer_region_t *pstruct = (const ur_buffer_region_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_BUFFER_CHANNEL_PROPERTIES: {
-        const ur_buffer_channel_properties_t *pstruct = (const ur_buffer_channel_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_BUFFER_ALLOC_LOCATION_PROPERTIES: {
-        const ur_buffer_alloc_location_properties_t *pstruct = (const ur_buffer_alloc_location_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES: {
-        const ur_program_properties_t *pstruct = (const ur_program_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_USM_DESC: {
-        const ur_usm_desc_t *pstruct = (const ur_usm_desc_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_USM_HOST_DESC: {
-        const ur_usm_host_desc_t *pstruct = (const ur_usm_host_desc_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_USM_DEVICE_DESC: {
-        const ur_usm_device_desc_t *pstruct = (const ur_usm_device_desc_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_USM_POOL_DESC: {
-        const ur_usm_pool_desc_t *pstruct = (const ur_usm_pool_desc_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_USM_POOL_LIMITS_DESC: {
-        const ur_usm_pool_limits_desc_t *pstruct = (const ur_usm_pool_limits_desc_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_DEVICE_BINARY: {
-        const ur_device_binary_t *pstruct = (const ur_device_binary_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_SAMPLER_DESC: {
-        const ur_sampler_desc_t *pstruct = (const ur_sampler_desc_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_QUEUE_PROPERTIES: {
-        const ur_queue_properties_t *pstruct = (const ur_queue_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_QUEUE_INDEX_PROPERTIES: {
-        const ur_queue_index_properties_t *pstruct = (const ur_queue_index_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_CONTEXT_NATIVE_PROPERTIES: {
-        const ur_context_native_properties_t *pstruct = (const ur_context_native_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_KERNEL_NATIVE_PROPERTIES: {
-        const ur_kernel_native_properties_t *pstruct = (const ur_kernel_native_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_QUEUE_NATIVE_PROPERTIES: {
-        const ur_queue_native_properties_t *pstruct = (const ur_queue_native_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_MEM_NATIVE_PROPERTIES: {
-        const ur_mem_native_properties_t *pstruct = (const ur_mem_native_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_EVENT_NATIVE_PROPERTIES: {
-        const ur_event_native_properties_t *pstruct = (const ur_event_native_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_PLATFORM_NATIVE_PROPERTIES: {
-        const ur_platform_native_properties_t *pstruct = (const ur_platform_native_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_DEVICE_NATIVE_PROPERTIES: {
-        const ur_device_native_properties_t *pstruct = (const ur_device_native_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_PROGRAM_NATIVE_PROPERTIES: {
-        const ur_program_native_properties_t *pstruct = (const ur_program_native_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_SAMPLER_NATIVE_PROPERTIES: {
-        const ur_sampler_native_properties_t *pstruct = (const ur_sampler_native_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_QUEUE_NATIVE_DESC: {
-        const ur_queue_native_desc_t *pstruct = (const ur_queue_native_desc_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_DEVICE_PARTITION_PROPERTIES: {
-        const ur_device_partition_properties_t *pstruct = (const ur_device_partition_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_KERNEL_ARG_MEM_OBJ_PROPERTIES: {
-        const ur_kernel_arg_mem_obj_properties_t *pstruct = (const ur_kernel_arg_mem_obj_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_PHYSICAL_MEM_PROPERTIES: {
-        const ur_physical_mem_properties_t *pstruct = (const ur_physical_mem_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_KERNEL_ARG_POINTER_PROPERTIES: {
-        const ur_kernel_arg_pointer_properties_t *pstruct = (const ur_kernel_arg_pointer_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_KERNEL_ARG_SAMPLER_PROPERTIES: {
-        const ur_kernel_arg_sampler_properties_t *pstruct = (const ur_kernel_arg_sampler_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_KERNEL_EXEC_INFO_PROPERTIES: {
-        const ur_kernel_exec_info_properties_t *pstruct = (const ur_kernel_exec_info_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_KERNEL_ARG_VALUE_PROPERTIES: {
-        const ur_kernel_arg_value_properties_t *pstruct = (const ur_kernel_arg_value_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_KERNEL_ARG_LOCAL_PROPERTIES: {
-        const ur_kernel_arg_local_properties_t *pstruct = (const ur_kernel_arg_local_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_USM_ALLOC_LOCATION_DESC: {
-        const ur_usm_alloc_location_desc_t *pstruct = (const ur_usm_alloc_location_desc_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_DESC: {
-        const ur_exp_command_buffer_desc_t *pstruct = (const ur_exp_command_buffer_desc_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_KERNEL_LAUNCH_DESC: {
-        const ur_exp_command_buffer_update_kernel_launch_desc_t *pstruct = (const ur_exp_command_buffer_update_kernel_launch_desc_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_MEMOBJ_ARG_DESC: {
-        const ur_exp_command_buffer_update_memobj_arg_desc_t *pstruct = (const ur_exp_command_buffer_update_memobj_arg_desc_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_POINTER_ARG_DESC: {
-        const ur_exp_command_buffer_update_pointer_arg_desc_t *pstruct = (const ur_exp_command_buffer_update_pointer_arg_desc_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_VALUE_ARG_DESC: {
-        const ur_exp_command_buffer_update_value_arg_desc_t *pstruct = (const ur_exp_command_buffer_update_value_arg_desc_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_EXP_SAMPLER_MIP_PROPERTIES: {
-        const ur_exp_sampler_mip_properties_t *pstruct = (const ur_exp_sampler_mip_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_EXP_EXTERNAL_MEM_DESC: {
-        const ur_exp_external_mem_desc_t *pstruct = (const ur_exp_external_mem_desc_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_EXP_EXTERNAL_SEMAPHORE_DESC: {
-        const ur_exp_external_semaphore_desc_t *pstruct = (const ur_exp_external_semaphore_desc_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_EXP_FILE_DESCRIPTOR: {
-        const ur_exp_file_descriptor_t *pstruct = (const ur_exp_file_descriptor_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_EXP_WIN32_HANDLE: {
-        const ur_exp_win32_handle_t *pstruct = (const ur_exp_win32_handle_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_EXP_SAMPLER_ADDR_MODES: {
-        const ur_exp_sampler_addr_modes_t *pstruct = (const ur_exp_sampler_addr_modes_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_EXP_SAMPLER_CUBEMAP_PROPERTIES: {
-        const ur_exp_sampler_cubemap_properties_t *pstruct = (const ur_exp_sampler_cubemap_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_EXP_IMAGE_COPY_REGION: {
-        const ur_exp_image_copy_region_t *pstruct = (const ur_exp_image_copy_region_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-
-    case UR_STRUCTURE_TYPE_EXP_ENQUEUE_NATIVE_COMMAND_PROPERTIES: {
-        const ur_exp_enqueue_native_command_properties_t *pstruct = (const ur_exp_enqueue_native_command_properties_t *)ptr;
-        printPtr(os, pstruct);
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_result_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_result_t value) {
-    switch (value) {
-    case UR_RESULT_SUCCESS:
-        os << "UR_RESULT_SUCCESS";
-        break;
-    case UR_RESULT_ERROR_INVALID_OPERATION:
-        os << "UR_RESULT_ERROR_INVALID_OPERATION";
-        break;
-    case UR_RESULT_ERROR_INVALID_QUEUE_PROPERTIES:
-        os << "UR_RESULT_ERROR_INVALID_QUEUE_PROPERTIES";
-        break;
-    case UR_RESULT_ERROR_INVALID_QUEUE:
-        os << "UR_RESULT_ERROR_INVALID_QUEUE";
-        break;
-    case UR_RESULT_ERROR_INVALID_VALUE:
-        os << "UR_RESULT_ERROR_INVALID_VALUE";
-        break;
-    case UR_RESULT_ERROR_INVALID_CONTEXT:
-        os << "UR_RESULT_ERROR_INVALID_CONTEXT";
-        break;
-    case UR_RESULT_ERROR_INVALID_PLATFORM:
-        os << "UR_RESULT_ERROR_INVALID_PLATFORM";
-        break;
-    case UR_RESULT_ERROR_INVALID_BINARY:
-        os << "UR_RESULT_ERROR_INVALID_BINARY";
-        break;
-    case UR_RESULT_ERROR_INVALID_PROGRAM:
-        os << "UR_RESULT_ERROR_INVALID_PROGRAM";
-        break;
-    case UR_RESULT_ERROR_INVALID_SAMPLER:
-        os << "UR_RESULT_ERROR_INVALID_SAMPLER";
-        break;
-    case UR_RESULT_ERROR_INVALID_BUFFER_SIZE:
-        os << "UR_RESULT_ERROR_INVALID_BUFFER_SIZE";
-        break;
-    case UR_RESULT_ERROR_INVALID_MEM_OBJECT:
-        os << "UR_RESULT_ERROR_INVALID_MEM_OBJECT";
-        break;
-    case UR_RESULT_ERROR_INVALID_EVENT:
-        os << "UR_RESULT_ERROR_INVALID_EVENT";
-        break;
-    case UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST:
-        os << "UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST";
-        break;
-    case UR_RESULT_ERROR_MISALIGNED_SUB_BUFFER_OFFSET:
-        os << "UR_RESULT_ERROR_MISALIGNED_SUB_BUFFER_OFFSET";
-        break;
-    case UR_RESULT_ERROR_INVALID_WORK_GROUP_SIZE:
-        os << "UR_RESULT_ERROR_INVALID_WORK_GROUP_SIZE";
-        break;
-    case UR_RESULT_ERROR_COMPILER_NOT_AVAILABLE:
-        os << "UR_RESULT_ERROR_COMPILER_NOT_AVAILABLE";
-        break;
-    case UR_RESULT_ERROR_PROFILING_INFO_NOT_AVAILABLE:
-        os << "UR_RESULT_ERROR_PROFILING_INFO_NOT_AVAILABLE";
-        break;
-    case UR_RESULT_ERROR_DEVICE_NOT_FOUND:
-        os << "UR_RESULT_ERROR_DEVICE_NOT_FOUND";
-        break;
-    case UR_RESULT_ERROR_INVALID_DEVICE:
-        os << "UR_RESULT_ERROR_INVALID_DEVICE";
-        break;
-    case UR_RESULT_ERROR_DEVICE_LOST:
-        os << "UR_RESULT_ERROR_DEVICE_LOST";
-        break;
-    case UR_RESULT_ERROR_DEVICE_REQUIRES_RESET:
-        os << "UR_RESULT_ERROR_DEVICE_REQUIRES_RESET";
-        break;
-    case UR_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE:
-        os << "UR_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE";
-        break;
-    case UR_RESULT_ERROR_DEVICE_PARTITION_FAILED:
-        os << "UR_RESULT_ERROR_DEVICE_PARTITION_FAILED";
-        break;
-    case UR_RESULT_ERROR_INVALID_DEVICE_PARTITION_COUNT:
-        os << "UR_RESULT_ERROR_INVALID_DEVICE_PARTITION_COUNT";
-        break;
-    case UR_RESULT_ERROR_INVALID_WORK_ITEM_SIZE:
-        os << "UR_RESULT_ERROR_INVALID_WORK_ITEM_SIZE";
-        break;
-    case UR_RESULT_ERROR_INVALID_WORK_DIMENSION:
-        os << "UR_RESULT_ERROR_INVALID_WORK_DIMENSION";
-        break;
-    case UR_RESULT_ERROR_INVALID_KERNEL_ARGS:
-        os << "UR_RESULT_ERROR_INVALID_KERNEL_ARGS";
-        break;
-    case UR_RESULT_ERROR_INVALID_KERNEL:
-        os << "UR_RESULT_ERROR_INVALID_KERNEL";
-        break;
-    case UR_RESULT_ERROR_INVALID_KERNEL_NAME:
-        os << "UR_RESULT_ERROR_INVALID_KERNEL_NAME";
-        break;
-    case UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_INDEX:
-        os << "UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_INDEX";
-        break;
-    case UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_SIZE:
-        os << "UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_SIZE";
-        break;
-    case UR_RESULT_ERROR_INVALID_KERNEL_ATTRIBUTE_VALUE:
-        os << "UR_RESULT_ERROR_INVALID_KERNEL_ATTRIBUTE_VALUE";
-        break;
-    case UR_RESULT_ERROR_INVALID_IMAGE_SIZE:
-        os << "UR_RESULT_ERROR_INVALID_IMAGE_SIZE";
-        break;
-    case UR_RESULT_ERROR_INVALID_IMAGE_FORMAT_DESCRIPTOR:
-        os << "UR_RESULT_ERROR_INVALID_IMAGE_FORMAT_DESCRIPTOR";
-        break;
-    case UR_RESULT_ERROR_MEM_OBJECT_ALLOCATION_FAILURE:
-        os << "UR_RESULT_ERROR_MEM_OBJECT_ALLOCATION_FAILURE";
-        break;
-    case UR_RESULT_ERROR_INVALID_PROGRAM_EXECUTABLE:
-        os << "UR_RESULT_ERROR_INVALID_PROGRAM_EXECUTABLE";
-        break;
-    case UR_RESULT_ERROR_UNINITIALIZED:
-        os << "UR_RESULT_ERROR_UNINITIALIZED";
-        break;
-    case UR_RESULT_ERROR_OUT_OF_HOST_MEMORY:
-        os << "UR_RESULT_ERROR_OUT_OF_HOST_MEMORY";
-        break;
-    case UR_RESULT_ERROR_OUT_OF_DEVICE_MEMORY:
-        os << "UR_RESULT_ERROR_OUT_OF_DEVICE_MEMORY";
-        break;
-    case UR_RESULT_ERROR_OUT_OF_RESOURCES:
-        os << "UR_RESULT_ERROR_OUT_OF_RESOURCES";
-        break;
-    case UR_RESULT_ERROR_PROGRAM_BUILD_FAILURE:
-        os << "UR_RESULT_ERROR_PROGRAM_BUILD_FAILURE";
-        break;
-    case UR_RESULT_ERROR_PROGRAM_LINK_FAILURE:
-        os << "UR_RESULT_ERROR_PROGRAM_LINK_FAILURE";
-        break;
-    case UR_RESULT_ERROR_UNSUPPORTED_VERSION:
-        os << "UR_RESULT_ERROR_UNSUPPORTED_VERSION";
-        break;
-    case UR_RESULT_ERROR_UNSUPPORTED_FEATURE:
-        os << "UR_RESULT_ERROR_UNSUPPORTED_FEATURE";
-        break;
-    case UR_RESULT_ERROR_INVALID_ARGUMENT:
-        os << "UR_RESULT_ERROR_INVALID_ARGUMENT";
-        break;
-    case UR_RESULT_ERROR_INVALID_NULL_HANDLE:
-        os << "UR_RESULT_ERROR_INVALID_NULL_HANDLE";
-        break;
-    case UR_RESULT_ERROR_HANDLE_OBJECT_IN_USE:
-        os << "UR_RESULT_ERROR_HANDLE_OBJECT_IN_USE";
-        break;
-    case UR_RESULT_ERROR_INVALID_NULL_POINTER:
-        os << "UR_RESULT_ERROR_INVALID_NULL_POINTER";
-        break;
-    case UR_RESULT_ERROR_INVALID_SIZE:
-        os << "UR_RESULT_ERROR_INVALID_SIZE";
-        break;
-    case UR_RESULT_ERROR_UNSUPPORTED_SIZE:
-        os << "UR_RESULT_ERROR_UNSUPPORTED_SIZE";
-        break;
-    case UR_RESULT_ERROR_UNSUPPORTED_ALIGNMENT:
-        os << "UR_RESULT_ERROR_UNSUPPORTED_ALIGNMENT";
-        break;
-    case UR_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT:
-        os << "UR_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT";
-        break;
-    case UR_RESULT_ERROR_INVALID_ENUMERATION:
-        os << "UR_RESULT_ERROR_INVALID_ENUMERATION";
-        break;
-    case UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION:
-        os << "UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION";
-        break;
-    case UR_RESULT_ERROR_UNSUPPORTED_IMAGE_FORMAT:
-        os << "UR_RESULT_ERROR_UNSUPPORTED_IMAGE_FORMAT";
-        break;
-    case UR_RESULT_ERROR_INVALID_NATIVE_BINARY:
-        os << "UR_RESULT_ERROR_INVALID_NATIVE_BINARY";
-        break;
-    case UR_RESULT_ERROR_INVALID_GLOBAL_NAME:
-        os << "UR_RESULT_ERROR_INVALID_GLOBAL_NAME";
-        break;
-    case UR_RESULT_ERROR_FUNCTION_ADDRESS_NOT_AVAILABLE:
-        os << "UR_RESULT_ERROR_FUNCTION_ADDRESS_NOT_AVAILABLE";
-        break;
-    case UR_RESULT_ERROR_INVALID_GROUP_SIZE_DIMENSION:
-        os << "UR_RESULT_ERROR_INVALID_GROUP_SIZE_DIMENSION";
-        break;
-    case UR_RESULT_ERROR_INVALID_GLOBAL_WIDTH_DIMENSION:
-        os << "UR_RESULT_ERROR_INVALID_GLOBAL_WIDTH_DIMENSION";
-        break;
-    case UR_RESULT_ERROR_PROGRAM_UNLINKED:
-        os << "UR_RESULT_ERROR_PROGRAM_UNLINKED";
-        break;
-    case UR_RESULT_ERROR_OVERLAPPING_REGIONS:
-        os << "UR_RESULT_ERROR_OVERLAPPING_REGIONS";
-        break;
-    case UR_RESULT_ERROR_INVALID_HOST_PTR:
-        os << "UR_RESULT_ERROR_INVALID_HOST_PTR";
-        break;
-    case UR_RESULT_ERROR_INVALID_USM_SIZE:
-        os << "UR_RESULT_ERROR_INVALID_USM_SIZE";
-        break;
-    case UR_RESULT_ERROR_OBJECT_ALLOCATION_FAILURE:
-        os << "UR_RESULT_ERROR_OBJECT_ALLOCATION_FAILURE";
-        break;
-    case UR_RESULT_ERROR_ADAPTER_SPECIFIC:
-        os << "UR_RESULT_ERROR_ADAPTER_SPECIFIC";
-        break;
-    case UR_RESULT_ERROR_LAYER_NOT_PRESENT:
-        os << "UR_RESULT_ERROR_LAYER_NOT_PRESENT";
-        break;
-    case UR_RESULT_ERROR_IN_EVENT_LIST_EXEC_STATUS:
-        os << "UR_RESULT_ERROR_IN_EVENT_LIST_EXEC_STATUS";
-        break;
-    case UR_RESULT_ERROR_DEVICE_NOT_AVAILABLE:
-        os << "UR_RESULT_ERROR_DEVICE_NOT_AVAILABLE";
-        break;
-    case UR_RESULT_ERROR_INVALID_SPEC_ID:
-        os << "UR_RESULT_ERROR_INVALID_SPEC_ID";
-        break;
-    case UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_EXP:
-        os << "UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_EXP";
-        break;
-    case UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_SYNC_POINT_EXP:
-        os << "UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_SYNC_POINT_EXP";
-        break;
-    case UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_SYNC_POINT_WAIT_LIST_EXP:
-        os << "UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_SYNC_POINT_WAIT_LIST_EXP";
-        break;
-    case UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_COMMAND_HANDLE_EXP:
-        os << "UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_COMMAND_HANDLE_EXP";
-        break;
-    case UR_RESULT_ERROR_UNKNOWN:
-        os << "UR_RESULT_ERROR_UNKNOWN";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_base_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_base_properties_t params) {
-    os << "(struct ur_base_properties_t){";
-
-    os << ".stype = ";
-
-    os << (params.stype);
-
-    os << ", ";
-    os << ".pNext = ";
-
-    ur::details::printStruct(os,
-                             (params.pNext));
-
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_base_desc_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_base_desc_t params) {
-    os << "(struct ur_base_desc_t){";
-
-    os << ".stype = ";
-
-    os << (params.stype);
-
-    os << ", ";
-    os << ".pNext = ";
-
-    ur::details::printStruct(os,
-                             (params.pNext));
-
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_rect_offset_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_rect_offset_t params) {
-    os << "(struct ur_rect_offset_t){";
-
-    os << ".x = ";
-
-    os << (params.x);
-
-    os << ", ";
-    os << ".y = ";
-
-    os << (params.y);
-
-    os << ", ";
-    os << ".z = ";
-
-    os << (params.z);
-
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_rect_region_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_rect_region_t params) {
-    os << "(struct ur_rect_region_t){";
-
-    os << ".width = ";
-
-    os << (params.width);
-
-    os << ", ";
-    os << ".height = ";
-
-    os << (params.height);
-
-    os << ", ";
-    os << ".depth = ";
-
-    os << (params.depth);
-
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_device_init_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_init_flag_t value) {
-    switch (value) {
-    case UR_DEVICE_INIT_FLAG_GPU:
-        os << "UR_DEVICE_INIT_FLAG_GPU";
-        break;
-    case UR_DEVICE_INIT_FLAG_CPU:
-        os << "UR_DEVICE_INIT_FLAG_CPU";
-        break;
-    case UR_DEVICE_INIT_FLAG_FPGA:
-        os << "UR_DEVICE_INIT_FLAG_FPGA";
-        break;
-    case UR_DEVICE_INIT_FLAG_MCA:
-        os << "UR_DEVICE_INIT_FLAG_MCA";
-        break;
-    case UR_DEVICE_INIT_FLAG_VPU:
-        os << "UR_DEVICE_INIT_FLAG_VPU";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_device_init_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_device_init_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_DEVICE_INIT_FLAG_GPU) == (uint32_t)UR_DEVICE_INIT_FLAG_GPU) {
-        val ^= (uint32_t)UR_DEVICE_INIT_FLAG_GPU;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_INIT_FLAG_GPU;
-    }
-
-    if ((val & UR_DEVICE_INIT_FLAG_CPU) == (uint32_t)UR_DEVICE_INIT_FLAG_CPU) {
-        val ^= (uint32_t)UR_DEVICE_INIT_FLAG_CPU;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_INIT_FLAG_CPU;
-    }
-
-    if ((val & UR_DEVICE_INIT_FLAG_FPGA) == (uint32_t)UR_DEVICE_INIT_FLAG_FPGA) {
-        val ^= (uint32_t)UR_DEVICE_INIT_FLAG_FPGA;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_INIT_FLAG_FPGA;
-    }
-
-    if ((val & UR_DEVICE_INIT_FLAG_MCA) == (uint32_t)UR_DEVICE_INIT_FLAG_MCA) {
-        val ^= (uint32_t)UR_DEVICE_INIT_FLAG_MCA;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_INIT_FLAG_MCA;
-    }
-
-    if ((val & UR_DEVICE_INIT_FLAG_VPU) == (uint32_t)UR_DEVICE_INIT_FLAG_VPU) {
-        val ^= (uint32_t)UR_DEVICE_INIT_FLAG_VPU;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_INIT_FLAG_VPU;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_loader_config_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_loader_config_info_t value) {
-    switch (value) {
-    case UR_LOADER_CONFIG_INFO_AVAILABLE_LAYERS:
-        os << "UR_LOADER_CONFIG_INFO_AVAILABLE_LAYERS";
-        break;
-    case UR_LOADER_CONFIG_INFO_REFERENCE_COUNT:
-        os << "UR_LOADER_CONFIG_INFO_REFERENCE_COUNT";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_loader_config_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_loader_config_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
-
-    switch (value) {
-    case UR_LOADER_CONFIG_INFO_AVAILABLE_LAYERS: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_LOADER_CONFIG_INFO_REFERENCE_COUNT: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_code_location_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_code_location_t params) {
-    os << "(struct ur_code_location_t){";
-
-    os << ".functionName = ";
-
-    ur::details::printPtr(os,
-                          (params.functionName));
-
-    os << ", ";
-    os << ".sourceFile = ";
-
-    ur::details::printPtr(os,
-                          (params.sourceFile));
-
-    os << ", ";
-    os << ".lineNumber = ";
-
-    os << (params.lineNumber);
-
-    os << ", ";
-    os << ".columnNumber = ";
-
-    os << (params.columnNumber);
-
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_adapter_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_adapter_info_t value) {
-    switch (value) {
-    case UR_ADAPTER_INFO_BACKEND:
-        os << "UR_ADAPTER_INFO_BACKEND";
-        break;
-    case UR_ADAPTER_INFO_REFERENCE_COUNT:
-        os << "UR_ADAPTER_INFO_REFERENCE_COUNT";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_adapter_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_adapter_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
-
-    switch (value) {
-    case UR_ADAPTER_INFO_BACKEND: {
-        const ur_adapter_backend_t *tptr = (const ur_adapter_backend_t *)ptr;
-        if (sizeof(ur_adapter_backend_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_adapter_backend_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_ADAPTER_INFO_REFERENCE_COUNT: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_adapter_backend_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_adapter_backend_t value) {
-    switch (value) {
-    case UR_ADAPTER_BACKEND_UNKNOWN:
-        os << "UR_ADAPTER_BACKEND_UNKNOWN";
-        break;
-    case UR_ADAPTER_BACKEND_LEVEL_ZERO:
-        os << "UR_ADAPTER_BACKEND_LEVEL_ZERO";
-        break;
-    case UR_ADAPTER_BACKEND_OPENCL:
-        os << "UR_ADAPTER_BACKEND_OPENCL";
-        break;
-    case UR_ADAPTER_BACKEND_CUDA:
-        os << "UR_ADAPTER_BACKEND_CUDA";
-        break;
-    case UR_ADAPTER_BACKEND_HIP:
-        os << "UR_ADAPTER_BACKEND_HIP";
-        break;
-    case UR_ADAPTER_BACKEND_NATIVE_CPU:
-        os << "UR_ADAPTER_BACKEND_NATIVE_CPU";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_platform_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_platform_info_t value) {
-    switch (value) {
-    case UR_PLATFORM_INFO_NAME:
-        os << "UR_PLATFORM_INFO_NAME";
-        break;
-    case UR_PLATFORM_INFO_VENDOR_NAME:
-        os << "UR_PLATFORM_INFO_VENDOR_NAME";
-        break;
-    case UR_PLATFORM_INFO_VERSION:
-        os << "UR_PLATFORM_INFO_VERSION";
-        break;
-    case UR_PLATFORM_INFO_EXTENSIONS:
-        os << "UR_PLATFORM_INFO_EXTENSIONS";
-        break;
-    case UR_PLATFORM_INFO_PROFILE:
-        os << "UR_PLATFORM_INFO_PROFILE";
-        break;
-    case UR_PLATFORM_INFO_BACKEND:
-        os << "UR_PLATFORM_INFO_BACKEND";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_platform_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_platform_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
-
-    switch (value) {
-    case UR_PLATFORM_INFO_NAME: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_PLATFORM_INFO_VENDOR_NAME: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_PLATFORM_INFO_VERSION: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_PLATFORM_INFO_EXTENSIONS: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_PLATFORM_INFO_PROFILE: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_PLATFORM_INFO_BACKEND: {
-        const ur_platform_backend_t *tptr = (const ur_platform_backend_t *)ptr;
-        if (sizeof(ur_platform_backend_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_platform_backend_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_api_version_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_api_version_t value) {
-    os << UR_MAJOR_VERSION(value) << "." << UR_MINOR_VERSION(value);
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_platform_native_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_platform_native_properties_t params) {
-    os << "(struct ur_platform_native_properties_t){";
-
-    os << ".stype = ";
-
-    os << (params.stype);
-
-    os << ", ";
-    os << ".pNext = ";
-
-    ur::details::printStruct(os,
-                             (params.pNext));
-
-    os << ", ";
-    os << ".isNativeHandleOwned = ";
-
-    os << (params.isNativeHandleOwned);
-
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_platform_backend_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_platform_backend_t value) {
-    switch (value) {
-    case UR_PLATFORM_BACKEND_UNKNOWN:
-        os << "UR_PLATFORM_BACKEND_UNKNOWN";
-        break;
-    case UR_PLATFORM_BACKEND_LEVEL_ZERO:
-        os << "UR_PLATFORM_BACKEND_LEVEL_ZERO";
-        break;
-    case UR_PLATFORM_BACKEND_OPENCL:
-        os << "UR_PLATFORM_BACKEND_OPENCL";
-        break;
-    case UR_PLATFORM_BACKEND_CUDA:
-        os << "UR_PLATFORM_BACKEND_CUDA";
-        break;
-    case UR_PLATFORM_BACKEND_HIP:
-        os << "UR_PLATFORM_BACKEND_HIP";
-        break;
-    case UR_PLATFORM_BACKEND_NATIVE_CPU:
-        os << "UR_PLATFORM_BACKEND_NATIVE_CPU";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_device_binary_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_device_binary_t params) {
-    os << "(struct ur_device_binary_t){";
-
-    os << ".stype = ";
-
-    os << (params.stype);
-
-    os << ", ";
-    os << ".pNext = ";
-
-    ur::details::printStruct(os,
-                             (params.pNext));
-
-    os << ", ";
-    os << ".pDeviceTargetSpec = ";
-
-    ur::details::printPtr(os,
-                          (params.pDeviceTargetSpec));
-
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_device_type_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_type_t value) {
-    switch (value) {
-    case UR_DEVICE_TYPE_DEFAULT:
-        os << "UR_DEVICE_TYPE_DEFAULT";
-        break;
-    case UR_DEVICE_TYPE_ALL:
-        os << "UR_DEVICE_TYPE_ALL";
-        break;
-    case UR_DEVICE_TYPE_GPU:
-        os << "UR_DEVICE_TYPE_GPU";
-        break;
-    case UR_DEVICE_TYPE_CPU:
-        os << "UR_DEVICE_TYPE_CPU";
-        break;
-    case UR_DEVICE_TYPE_FPGA:
-        os << "UR_DEVICE_TYPE_FPGA";
-        break;
-    case UR_DEVICE_TYPE_MCA:
-        os << "UR_DEVICE_TYPE_MCA";
-        break;
-    case UR_DEVICE_TYPE_VPU:
-        os << "UR_DEVICE_TYPE_VPU";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_device_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_info_t value) {
-    switch (value) {
-    case UR_DEVICE_INFO_TYPE:
-        os << "UR_DEVICE_INFO_TYPE";
-        break;
-    case UR_DEVICE_INFO_VENDOR_ID:
-        os << "UR_DEVICE_INFO_VENDOR_ID";
-        break;
-    case UR_DEVICE_INFO_DEVICE_ID:
-        os << "UR_DEVICE_INFO_DEVICE_ID";
-        break;
-    case UR_DEVICE_INFO_MAX_COMPUTE_UNITS:
-        os << "UR_DEVICE_INFO_MAX_COMPUTE_UNITS";
-        break;
-    case UR_DEVICE_INFO_MAX_WORK_ITEM_DIMENSIONS:
-        os << "UR_DEVICE_INFO_MAX_WORK_ITEM_DIMENSIONS";
-        break;
-    case UR_DEVICE_INFO_MAX_WORK_ITEM_SIZES:
-        os << "UR_DEVICE_INFO_MAX_WORK_ITEM_SIZES";
-        break;
-    case UR_DEVICE_INFO_MAX_WORK_GROUP_SIZE:
-        os << "UR_DEVICE_INFO_MAX_WORK_GROUP_SIZE";
-        break;
-    case UR_DEVICE_INFO_SINGLE_FP_CONFIG:
-        os << "UR_DEVICE_INFO_SINGLE_FP_CONFIG";
-        break;
-    case UR_DEVICE_INFO_HALF_FP_CONFIG:
-        os << "UR_DEVICE_INFO_HALF_FP_CONFIG";
-        break;
-    case UR_DEVICE_INFO_DOUBLE_FP_CONFIG:
-        os << "UR_DEVICE_INFO_DOUBLE_FP_CONFIG";
-        break;
-    case UR_DEVICE_INFO_QUEUE_PROPERTIES:
-        os << "UR_DEVICE_INFO_QUEUE_PROPERTIES";
-        break;
-    case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_CHAR:
-        os << "UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_CHAR";
-        break;
-    case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_SHORT:
-        os << "UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_SHORT";
-        break;
-    case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_INT:
-        os << "UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_INT";
-        break;
-    case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_LONG:
-        os << "UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_LONG";
-        break;
-    case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_FLOAT:
-        os << "UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_FLOAT";
-        break;
-    case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_DOUBLE:
-        os << "UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_DOUBLE";
-        break;
-    case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_HALF:
-        os << "UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_HALF";
-        break;
-    case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_CHAR:
-        os << "UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_CHAR";
-        break;
-    case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_SHORT:
-        os << "UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_SHORT";
-        break;
-    case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_INT:
-        os << "UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_INT";
-        break;
-    case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_LONG:
-        os << "UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_LONG";
-        break;
-    case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_FLOAT:
-        os << "UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_FLOAT";
-        break;
-    case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_DOUBLE:
-        os << "UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_DOUBLE";
-        break;
-    case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF:
-        os << "UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF";
-        break;
-    case UR_DEVICE_INFO_MAX_CLOCK_FREQUENCY:
-        os << "UR_DEVICE_INFO_MAX_CLOCK_FREQUENCY";
-        break;
-    case UR_DEVICE_INFO_MEMORY_CLOCK_RATE:
-        os << "UR_DEVICE_INFO_MEMORY_CLOCK_RATE";
-        break;
-    case UR_DEVICE_INFO_ADDRESS_BITS:
-        os << "UR_DEVICE_INFO_ADDRESS_BITS";
-        break;
-    case UR_DEVICE_INFO_MAX_MEM_ALLOC_SIZE:
-        os << "UR_DEVICE_INFO_MAX_MEM_ALLOC_SIZE";
-        break;
-    case UR_DEVICE_INFO_IMAGE_SUPPORTED:
-        os << "UR_DEVICE_INFO_IMAGE_SUPPORTED";
-        break;
-    case UR_DEVICE_INFO_MAX_READ_IMAGE_ARGS:
-        os << "UR_DEVICE_INFO_MAX_READ_IMAGE_ARGS";
-        break;
-    case UR_DEVICE_INFO_MAX_WRITE_IMAGE_ARGS:
-        os << "UR_DEVICE_INFO_MAX_WRITE_IMAGE_ARGS";
-        break;
-    case UR_DEVICE_INFO_MAX_READ_WRITE_IMAGE_ARGS:
-        os << "UR_DEVICE_INFO_MAX_READ_WRITE_IMAGE_ARGS";
-        break;
-    case UR_DEVICE_INFO_IMAGE2D_MAX_WIDTH:
-        os << "UR_DEVICE_INFO_IMAGE2D_MAX_WIDTH";
-        break;
-    case UR_DEVICE_INFO_IMAGE2D_MAX_HEIGHT:
-        os << "UR_DEVICE_INFO_IMAGE2D_MAX_HEIGHT";
-        break;
-    case UR_DEVICE_INFO_IMAGE3D_MAX_WIDTH:
-        os << "UR_DEVICE_INFO_IMAGE3D_MAX_WIDTH";
-        break;
-    case UR_DEVICE_INFO_IMAGE3D_MAX_HEIGHT:
-        os << "UR_DEVICE_INFO_IMAGE3D_MAX_HEIGHT";
-        break;
-    case UR_DEVICE_INFO_IMAGE3D_MAX_DEPTH:
-        os << "UR_DEVICE_INFO_IMAGE3D_MAX_DEPTH";
-        break;
-    case UR_DEVICE_INFO_IMAGE_MAX_BUFFER_SIZE:
-        os << "UR_DEVICE_INFO_IMAGE_MAX_BUFFER_SIZE";
-        break;
-    case UR_DEVICE_INFO_IMAGE_MAX_ARRAY_SIZE:
-        os << "UR_DEVICE_INFO_IMAGE_MAX_ARRAY_SIZE";
-        break;
-    case UR_DEVICE_INFO_MAX_SAMPLERS:
-        os << "UR_DEVICE_INFO_MAX_SAMPLERS";
-        break;
-    case UR_DEVICE_INFO_MAX_PARAMETER_SIZE:
-        os << "UR_DEVICE_INFO_MAX_PARAMETER_SIZE";
-        break;
-    case UR_DEVICE_INFO_MEM_BASE_ADDR_ALIGN:
-        os << "UR_DEVICE_INFO_MEM_BASE_ADDR_ALIGN";
-        break;
-    case UR_DEVICE_INFO_GLOBAL_MEM_CACHE_TYPE:
-        os << "UR_DEVICE_INFO_GLOBAL_MEM_CACHE_TYPE";
-        break;
-    case UR_DEVICE_INFO_GLOBAL_MEM_CACHELINE_SIZE:
-        os << "UR_DEVICE_INFO_GLOBAL_MEM_CACHELINE_SIZE";
-        break;
-    case UR_DEVICE_INFO_GLOBAL_MEM_CACHE_SIZE:
-        os << "UR_DEVICE_INFO_GLOBAL_MEM_CACHE_SIZE";
-        break;
-    case UR_DEVICE_INFO_GLOBAL_MEM_SIZE:
-        os << "UR_DEVICE_INFO_GLOBAL_MEM_SIZE";
-        break;
-    case UR_DEVICE_INFO_GLOBAL_MEM_FREE:
-        os << "UR_DEVICE_INFO_GLOBAL_MEM_FREE";
-        break;
-    case UR_DEVICE_INFO_MAX_CONSTANT_BUFFER_SIZE:
-        os << "UR_DEVICE_INFO_MAX_CONSTANT_BUFFER_SIZE";
-        break;
-    case UR_DEVICE_INFO_MAX_CONSTANT_ARGS:
-        os << "UR_DEVICE_INFO_MAX_CONSTANT_ARGS";
-        break;
-    case UR_DEVICE_INFO_LOCAL_MEM_TYPE:
-        os << "UR_DEVICE_INFO_LOCAL_MEM_TYPE";
-        break;
-    case UR_DEVICE_INFO_LOCAL_MEM_SIZE:
-        os << "UR_DEVICE_INFO_LOCAL_MEM_SIZE";
-        break;
-    case UR_DEVICE_INFO_ERROR_CORRECTION_SUPPORT:
-        os << "UR_DEVICE_INFO_ERROR_CORRECTION_SUPPORT";
-        break;
-    case UR_DEVICE_INFO_HOST_UNIFIED_MEMORY:
-        os << "UR_DEVICE_INFO_HOST_UNIFIED_MEMORY";
-        break;
-    case UR_DEVICE_INFO_PROFILING_TIMER_RESOLUTION:
-        os << "UR_DEVICE_INFO_PROFILING_TIMER_RESOLUTION";
-        break;
-    case UR_DEVICE_INFO_ENDIAN_LITTLE:
-        os << "UR_DEVICE_INFO_ENDIAN_LITTLE";
-        break;
-    case UR_DEVICE_INFO_AVAILABLE:
-        os << "UR_DEVICE_INFO_AVAILABLE";
-        break;
-    case UR_DEVICE_INFO_COMPILER_AVAILABLE:
-        os << "UR_DEVICE_INFO_COMPILER_AVAILABLE";
-        break;
-    case UR_DEVICE_INFO_LINKER_AVAILABLE:
-        os << "UR_DEVICE_INFO_LINKER_AVAILABLE";
-        break;
-    case UR_DEVICE_INFO_EXECUTION_CAPABILITIES:
-        os << "UR_DEVICE_INFO_EXECUTION_CAPABILITIES";
-        break;
-    case UR_DEVICE_INFO_QUEUE_ON_DEVICE_PROPERTIES:
-        os << "UR_DEVICE_INFO_QUEUE_ON_DEVICE_PROPERTIES";
-        break;
-    case UR_DEVICE_INFO_QUEUE_ON_HOST_PROPERTIES:
-        os << "UR_DEVICE_INFO_QUEUE_ON_HOST_PROPERTIES";
-        break;
-    case UR_DEVICE_INFO_BUILT_IN_KERNELS:
-        os << "UR_DEVICE_INFO_BUILT_IN_KERNELS";
-        break;
-    case UR_DEVICE_INFO_PLATFORM:
-        os << "UR_DEVICE_INFO_PLATFORM";
-        break;
-    case UR_DEVICE_INFO_REFERENCE_COUNT:
-        os << "UR_DEVICE_INFO_REFERENCE_COUNT";
-        break;
-    case UR_DEVICE_INFO_IL_VERSION:
-        os << "UR_DEVICE_INFO_IL_VERSION";
-        break;
-    case UR_DEVICE_INFO_NAME:
-        os << "UR_DEVICE_INFO_NAME";
-        break;
-    case UR_DEVICE_INFO_VENDOR:
-        os << "UR_DEVICE_INFO_VENDOR";
-        break;
-    case UR_DEVICE_INFO_DRIVER_VERSION:
-        os << "UR_DEVICE_INFO_DRIVER_VERSION";
-        break;
-    case UR_DEVICE_INFO_PROFILE:
-        os << "UR_DEVICE_INFO_PROFILE";
-        break;
-    case UR_DEVICE_INFO_VERSION:
-        os << "UR_DEVICE_INFO_VERSION";
-        break;
-    case UR_DEVICE_INFO_BACKEND_RUNTIME_VERSION:
-        os << "UR_DEVICE_INFO_BACKEND_RUNTIME_VERSION";
-        break;
-    case UR_DEVICE_INFO_EXTENSIONS:
-        os << "UR_DEVICE_INFO_EXTENSIONS";
-        break;
-    case UR_DEVICE_INFO_PRINTF_BUFFER_SIZE:
-        os << "UR_DEVICE_INFO_PRINTF_BUFFER_SIZE";
-        break;
-    case UR_DEVICE_INFO_PREFERRED_INTEROP_USER_SYNC:
-        os << "UR_DEVICE_INFO_PREFERRED_INTEROP_USER_SYNC";
-        break;
-    case UR_DEVICE_INFO_PARENT_DEVICE:
-        os << "UR_DEVICE_INFO_PARENT_DEVICE";
-        break;
-    case UR_DEVICE_INFO_SUPPORTED_PARTITIONS:
-        os << "UR_DEVICE_INFO_SUPPORTED_PARTITIONS";
-        break;
-    case UR_DEVICE_INFO_PARTITION_MAX_SUB_DEVICES:
-        os << "UR_DEVICE_INFO_PARTITION_MAX_SUB_DEVICES";
-        break;
-    case UR_DEVICE_INFO_PARTITION_AFFINITY_DOMAIN:
-        os << "UR_DEVICE_INFO_PARTITION_AFFINITY_DOMAIN";
-        break;
-    case UR_DEVICE_INFO_PARTITION_TYPE:
-        os << "UR_DEVICE_INFO_PARTITION_TYPE";
-        break;
-    case UR_DEVICE_INFO_MAX_NUM_SUB_GROUPS:
-        os << "UR_DEVICE_INFO_MAX_NUM_SUB_GROUPS";
-        break;
-    case UR_DEVICE_INFO_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS:
-        os << "UR_DEVICE_INFO_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS";
-        break;
-    case UR_DEVICE_INFO_SUB_GROUP_SIZES_INTEL:
-        os << "UR_DEVICE_INFO_SUB_GROUP_SIZES_INTEL";
-        break;
-    case UR_DEVICE_INFO_USM_HOST_SUPPORT:
-        os << "UR_DEVICE_INFO_USM_HOST_SUPPORT";
-        break;
-    case UR_DEVICE_INFO_USM_DEVICE_SUPPORT:
-        os << "UR_DEVICE_INFO_USM_DEVICE_SUPPORT";
-        break;
-    case UR_DEVICE_INFO_USM_SINGLE_SHARED_SUPPORT:
-        os << "UR_DEVICE_INFO_USM_SINGLE_SHARED_SUPPORT";
-        break;
-    case UR_DEVICE_INFO_USM_CROSS_SHARED_SUPPORT:
-        os << "UR_DEVICE_INFO_USM_CROSS_SHARED_SUPPORT";
-        break;
-    case UR_DEVICE_INFO_USM_SYSTEM_SHARED_SUPPORT:
-        os << "UR_DEVICE_INFO_USM_SYSTEM_SHARED_SUPPORT";
-        break;
-    case UR_DEVICE_INFO_UUID:
-        os << "UR_DEVICE_INFO_UUID";
-        break;
-    case UR_DEVICE_INFO_PCI_ADDRESS:
-        os << "UR_DEVICE_INFO_PCI_ADDRESS";
-        break;
-    case UR_DEVICE_INFO_GPU_EU_COUNT:
-        os << "UR_DEVICE_INFO_GPU_EU_COUNT";
-        break;
-    case UR_DEVICE_INFO_GPU_EU_SIMD_WIDTH:
-        os << "UR_DEVICE_INFO_GPU_EU_SIMD_WIDTH";
-        break;
-    case UR_DEVICE_INFO_GPU_EU_SLICES:
-        os << "UR_DEVICE_INFO_GPU_EU_SLICES";
-        break;
-    case UR_DEVICE_INFO_GPU_EU_COUNT_PER_SUBSLICE:
-        os << "UR_DEVICE_INFO_GPU_EU_COUNT_PER_SUBSLICE";
-        break;
-    case UR_DEVICE_INFO_GPU_SUBSLICES_PER_SLICE:
-        os << "UR_DEVICE_INFO_GPU_SUBSLICES_PER_SLICE";
-        break;
-    case UR_DEVICE_INFO_GPU_HW_THREADS_PER_EU:
-        os << "UR_DEVICE_INFO_GPU_HW_THREADS_PER_EU";
-        break;
-    case UR_DEVICE_INFO_MAX_MEMORY_BANDWIDTH:
-        os << "UR_DEVICE_INFO_MAX_MEMORY_BANDWIDTH";
-        break;
-    case UR_DEVICE_INFO_IMAGE_SRGB:
-        os << "UR_DEVICE_INFO_IMAGE_SRGB";
-        break;
-    case UR_DEVICE_INFO_BUILD_ON_SUBDEVICE:
-        os << "UR_DEVICE_INFO_BUILD_ON_SUBDEVICE";
-        break;
-    case UR_DEVICE_INFO_ATOMIC_64:
-        os << "UR_DEVICE_INFO_ATOMIC_64";
-        break;
-    case UR_DEVICE_INFO_ATOMIC_MEMORY_ORDER_CAPABILITIES:
-        os << "UR_DEVICE_INFO_ATOMIC_MEMORY_ORDER_CAPABILITIES";
-        break;
-    case UR_DEVICE_INFO_ATOMIC_MEMORY_SCOPE_CAPABILITIES:
-        os << "UR_DEVICE_INFO_ATOMIC_MEMORY_SCOPE_CAPABILITIES";
-        break;
-    case UR_DEVICE_INFO_ATOMIC_FENCE_ORDER_CAPABILITIES:
-        os << "UR_DEVICE_INFO_ATOMIC_FENCE_ORDER_CAPABILITIES";
-        break;
-    case UR_DEVICE_INFO_ATOMIC_FENCE_SCOPE_CAPABILITIES:
-        os << "UR_DEVICE_INFO_ATOMIC_FENCE_SCOPE_CAPABILITIES";
-        break;
-    case UR_DEVICE_INFO_BFLOAT16:
-        os << "UR_DEVICE_INFO_BFLOAT16";
-        break;
-    case UR_DEVICE_INFO_MAX_COMPUTE_QUEUE_INDICES:
-        os << "UR_DEVICE_INFO_MAX_COMPUTE_QUEUE_INDICES";
-        break;
-    case UR_DEVICE_INFO_KERNEL_SET_SPECIALIZATION_CONSTANTS:
-        os << "UR_DEVICE_INFO_KERNEL_SET_SPECIALIZATION_CONSTANTS";
-        break;
-    case UR_DEVICE_INFO_MEMORY_BUS_WIDTH:
-        os << "UR_DEVICE_INFO_MEMORY_BUS_WIDTH";
-        break;
-    case UR_DEVICE_INFO_MAX_WORK_GROUPS_3D:
-        os << "UR_DEVICE_INFO_MAX_WORK_GROUPS_3D";
-        break;
-    case UR_DEVICE_INFO_ASYNC_BARRIER:
-        os << "UR_DEVICE_INFO_ASYNC_BARRIER";
-        break;
-    case UR_DEVICE_INFO_MEM_CHANNEL_SUPPORT:
-        os << "UR_DEVICE_INFO_MEM_CHANNEL_SUPPORT";
-        break;
-    case UR_DEVICE_INFO_HOST_PIPE_READ_WRITE_SUPPORTED:
-        os << "UR_DEVICE_INFO_HOST_PIPE_READ_WRITE_SUPPORTED";
-        break;
-    case UR_DEVICE_INFO_MAX_REGISTERS_PER_WORK_GROUP:
-        os << "UR_DEVICE_INFO_MAX_REGISTERS_PER_WORK_GROUP";
-        break;
-    case UR_DEVICE_INFO_IP_VERSION:
-        os << "UR_DEVICE_INFO_IP_VERSION";
-        break;
-    case UR_DEVICE_INFO_VIRTUAL_MEMORY_SUPPORT:
-        os << "UR_DEVICE_INFO_VIRTUAL_MEMORY_SUPPORT";
-        break;
-    case UR_DEVICE_INFO_ESIMD_SUPPORT:
-        os << "UR_DEVICE_INFO_ESIMD_SUPPORT";
-        break;
-    case UR_DEVICE_INFO_COMPONENT_DEVICES:
-        os << "UR_DEVICE_INFO_COMPONENT_DEVICES";
-        break;
-    case UR_DEVICE_INFO_COMPOSITE_DEVICE:
-        os << "UR_DEVICE_INFO_COMPOSITE_DEVICE";
-        break;
-    case UR_DEVICE_INFO_GLOBAL_VARIABLE_SUPPORT:
-        os << "UR_DEVICE_INFO_GLOBAL_VARIABLE_SUPPORT";
-        break;
-    case UR_DEVICE_INFO_COMMAND_BUFFER_SUPPORT_EXP:
-        os << "UR_DEVICE_INFO_COMMAND_BUFFER_SUPPORT_EXP";
-        break;
-    case UR_DEVICE_INFO_COMMAND_BUFFER_UPDATE_CAPABILITIES_EXP:
-        os << "UR_DEVICE_INFO_COMMAND_BUFFER_UPDATE_CAPABILITIES_EXP";
-        break;
-    case UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP:
-        os << "UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP";
-        break;
-    case UR_DEVICE_INFO_CLUSTER_LAUNCH_EXP:
-        os << "UR_DEVICE_INFO_CLUSTER_LAUNCH_EXP";
-        break;
-    case UR_DEVICE_INFO_BINDLESS_IMAGES_SUPPORT_EXP:
-        os << "UR_DEVICE_INFO_BINDLESS_IMAGES_SUPPORT_EXP";
-        break;
-    case UR_DEVICE_INFO_BINDLESS_IMAGES_SHARED_USM_SUPPORT_EXP:
-        os << "UR_DEVICE_INFO_BINDLESS_IMAGES_SHARED_USM_SUPPORT_EXP";
-        break;
-    case UR_DEVICE_INFO_BINDLESS_IMAGES_1D_USM_SUPPORT_EXP:
-        os << "UR_DEVICE_INFO_BINDLESS_IMAGES_1D_USM_SUPPORT_EXP";
-        break;
-    case UR_DEVICE_INFO_BINDLESS_IMAGES_2D_USM_SUPPORT_EXP:
-        os << "UR_DEVICE_INFO_BINDLESS_IMAGES_2D_USM_SUPPORT_EXP";
-        break;
-    case UR_DEVICE_INFO_IMAGE_PITCH_ALIGN_EXP:
-        os << "UR_DEVICE_INFO_IMAGE_PITCH_ALIGN_EXP";
-        break;
-    case UR_DEVICE_INFO_MAX_IMAGE_LINEAR_WIDTH_EXP:
-        os << "UR_DEVICE_INFO_MAX_IMAGE_LINEAR_WIDTH_EXP";
-        break;
-    case UR_DEVICE_INFO_MAX_IMAGE_LINEAR_HEIGHT_EXP:
-        os << "UR_DEVICE_INFO_MAX_IMAGE_LINEAR_HEIGHT_EXP";
-        break;
-    case UR_DEVICE_INFO_MAX_IMAGE_LINEAR_PITCH_EXP:
-        os << "UR_DEVICE_INFO_MAX_IMAGE_LINEAR_PITCH_EXP";
-        break;
-    case UR_DEVICE_INFO_MIPMAP_SUPPORT_EXP:
-        os << "UR_DEVICE_INFO_MIPMAP_SUPPORT_EXP";
-        break;
-    case UR_DEVICE_INFO_MIPMAP_ANISOTROPY_SUPPORT_EXP:
-        os << "UR_DEVICE_INFO_MIPMAP_ANISOTROPY_SUPPORT_EXP";
-        break;
-    case UR_DEVICE_INFO_MIPMAP_MAX_ANISOTROPY_EXP:
-        os << "UR_DEVICE_INFO_MIPMAP_MAX_ANISOTROPY_EXP";
-        break;
-    case UR_DEVICE_INFO_MIPMAP_LEVEL_REFERENCE_SUPPORT_EXP:
-        os << "UR_DEVICE_INFO_MIPMAP_LEVEL_REFERENCE_SUPPORT_EXP";
-        break;
-    case UR_DEVICE_INFO_EXTERNAL_MEMORY_IMPORT_SUPPORT_EXP:
-        os << "UR_DEVICE_INFO_EXTERNAL_MEMORY_IMPORT_SUPPORT_EXP";
-        break;
-    case UR_DEVICE_INFO_EXTERNAL_SEMAPHORE_IMPORT_SUPPORT_EXP:
-        os << "UR_DEVICE_INFO_EXTERNAL_SEMAPHORE_IMPORT_SUPPORT_EXP";
-        break;
-    case UR_DEVICE_INFO_CUBEMAP_SUPPORT_EXP:
-        os << "UR_DEVICE_INFO_CUBEMAP_SUPPORT_EXP";
-        break;
-    case UR_DEVICE_INFO_CUBEMAP_SEAMLESS_FILTERING_SUPPORT_EXP:
-        os << "UR_DEVICE_INFO_CUBEMAP_SEAMLESS_FILTERING_SUPPORT_EXP";
-        break;
-    case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_USM_EXP:
-        os << "UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_USM_EXP";
-        break;
-    case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_EXP:
-        os << "UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_EXP";
-        break;
-    case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_USM_EXP:
-        os << "UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_USM_EXP";
-        break;
-    case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_EXP:
-        os << "UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_EXP";
-        break;
-    case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_3D_EXP:
-        os << "UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_3D_EXP";
-        break;
-    case UR_DEVICE_INFO_TIMESTAMP_RECORDING_SUPPORT_EXP:
-        os << "UR_DEVICE_INFO_TIMESTAMP_RECORDING_SUPPORT_EXP";
-        break;
-    case UR_DEVICE_INFO_IMAGE_ARRAY_SUPPORT_EXP:
-        os << "UR_DEVICE_INFO_IMAGE_ARRAY_SUPPORT_EXP";
-        break;
-    case UR_DEVICE_INFO_BINDLESS_UNIQUE_ADDRESSING_PER_DIM_EXP:
-        os << "UR_DEVICE_INFO_BINDLESS_UNIQUE_ADDRESSING_PER_DIM_EXP";
-        break;
-    case UR_DEVICE_INFO_BINDLESS_SAMPLE_1D_USM_EXP:
-        os << "UR_DEVICE_INFO_BINDLESS_SAMPLE_1D_USM_EXP";
-        break;
-    case UR_DEVICE_INFO_BINDLESS_SAMPLE_2D_USM_EXP:
-        os << "UR_DEVICE_INFO_BINDLESS_SAMPLE_2D_USM_EXP";
-        break;
-    case UR_DEVICE_INFO_ENQUEUE_NATIVE_COMMAND_SUPPORT_EXP:
-        os << "UR_DEVICE_INFO_ENQUEUE_NATIVE_COMMAND_SUPPORT_EXP";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_device_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_device_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
-
-    switch (value) {
-    case UR_DEVICE_INFO_TYPE: {
-        const ur_device_type_t *tptr = (const ur_device_type_t *)ptr;
-        if (sizeof(ur_device_type_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_type_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_VENDOR_ID: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_DEVICE_ID: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MAX_COMPUTE_UNITS: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MAX_WORK_ITEM_DIMENSIONS: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MAX_WORK_ITEM_SIZES: {
-
-        const size_t *tptr = (const size_t *)ptr;
-        os << "{";
-        size_t nelems = size / sizeof(size_t);
-        for (size_t i = 0; i < nelems; ++i) {
-            if (i != 0) {
-                os << ", ";
-            }
-
-            os << tptr[i];
-        }
-        os << "}";
-    } break;
-    case UR_DEVICE_INFO_MAX_WORK_GROUP_SIZE: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_SINGLE_FP_CONFIG: {
-        const ur_device_fp_capability_flags_t *tptr = (const ur_device_fp_capability_flags_t *)ptr;
-        if (sizeof(ur_device_fp_capability_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_fp_capability_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_device_fp_capability_flag_t>(os,
-                                                               *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_HALF_FP_CONFIG: {
-        const ur_device_fp_capability_flags_t *tptr = (const ur_device_fp_capability_flags_t *)ptr;
-        if (sizeof(ur_device_fp_capability_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_fp_capability_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_device_fp_capability_flag_t>(os,
-                                                               *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_DOUBLE_FP_CONFIG: {
-        const ur_device_fp_capability_flags_t *tptr = (const ur_device_fp_capability_flags_t *)ptr;
-        if (sizeof(ur_device_fp_capability_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_fp_capability_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_device_fp_capability_flag_t>(os,
-                                                               *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_QUEUE_PROPERTIES: {
-        const ur_queue_flags_t *tptr = (const ur_queue_flags_t *)ptr;
-        if (sizeof(ur_queue_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_queue_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_queue_flag_t>(os,
-                                                *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_CHAR: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_SHORT: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_INT: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_LONG: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_FLOAT: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_DOUBLE: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_HALF: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_CHAR: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_SHORT: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_INT: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_LONG: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_FLOAT: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_DOUBLE: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MAX_CLOCK_FREQUENCY: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MEMORY_CLOCK_RATE: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_ADDRESS_BITS: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MAX_MEM_ALLOC_SIZE: {
-        const uint64_t *tptr = (const uint64_t *)ptr;
-        if (sizeof(uint64_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_IMAGE_SUPPORTED: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MAX_READ_IMAGE_ARGS: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MAX_WRITE_IMAGE_ARGS: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MAX_READ_WRITE_IMAGE_ARGS: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_IMAGE2D_MAX_WIDTH: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_IMAGE2D_MAX_HEIGHT: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_IMAGE3D_MAX_WIDTH: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_IMAGE3D_MAX_HEIGHT: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_IMAGE3D_MAX_DEPTH: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_IMAGE_MAX_BUFFER_SIZE: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_IMAGE_MAX_ARRAY_SIZE: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MAX_SAMPLERS: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MAX_PARAMETER_SIZE: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MEM_BASE_ADDR_ALIGN: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_GLOBAL_MEM_CACHE_TYPE: {
-        const ur_device_mem_cache_type_t *tptr = (const ur_device_mem_cache_type_t *)ptr;
-        if (sizeof(ur_device_mem_cache_type_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_mem_cache_type_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_GLOBAL_MEM_CACHELINE_SIZE: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_GLOBAL_MEM_CACHE_SIZE: {
-        const uint64_t *tptr = (const uint64_t *)ptr;
-        if (sizeof(uint64_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_GLOBAL_MEM_SIZE: {
-        const uint64_t *tptr = (const uint64_t *)ptr;
-        if (sizeof(uint64_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_GLOBAL_MEM_FREE: {
-        const uint64_t *tptr = (const uint64_t *)ptr;
-        if (sizeof(uint64_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MAX_CONSTANT_BUFFER_SIZE: {
-        const uint64_t *tptr = (const uint64_t *)ptr;
-        if (sizeof(uint64_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MAX_CONSTANT_ARGS: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_LOCAL_MEM_TYPE: {
-        const ur_device_local_mem_type_t *tptr = (const ur_device_local_mem_type_t *)ptr;
-        if (sizeof(ur_device_local_mem_type_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_local_mem_type_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_LOCAL_MEM_SIZE: {
-        const uint64_t *tptr = (const uint64_t *)ptr;
-        if (sizeof(uint64_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_ERROR_CORRECTION_SUPPORT: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_HOST_UNIFIED_MEMORY: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_PROFILING_TIMER_RESOLUTION: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_ENDIAN_LITTLE: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_AVAILABLE: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_COMPILER_AVAILABLE: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_LINKER_AVAILABLE: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_EXECUTION_CAPABILITIES: {
-        const ur_device_exec_capability_flags_t *tptr = (const ur_device_exec_capability_flags_t *)ptr;
-        if (sizeof(ur_device_exec_capability_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_exec_capability_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_device_exec_capability_flag_t>(os,
-                                                                 *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_QUEUE_ON_DEVICE_PROPERTIES: {
-        const ur_queue_flags_t *tptr = (const ur_queue_flags_t *)ptr;
-        if (sizeof(ur_queue_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_queue_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_queue_flag_t>(os,
-                                                *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_QUEUE_ON_HOST_PROPERTIES: {
-        const ur_queue_flags_t *tptr = (const ur_queue_flags_t *)ptr;
-        if (sizeof(ur_queue_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_queue_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_queue_flag_t>(os,
-                                                *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_BUILT_IN_KERNELS: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_DEVICE_INFO_PLATFORM: {
-        const ur_platform_handle_t *tptr = (const ur_platform_handle_t *)ptr;
-        if (sizeof(ur_platform_handle_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_platform_handle_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printPtr(os,
-                              *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_REFERENCE_COUNT: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_IL_VERSION: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_DEVICE_INFO_NAME: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_DEVICE_INFO_VENDOR: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_DEVICE_INFO_DRIVER_VERSION: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_DEVICE_INFO_PROFILE: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_DEVICE_INFO_VERSION: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_DEVICE_INFO_BACKEND_RUNTIME_VERSION: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_DEVICE_INFO_EXTENSIONS: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_DEVICE_INFO_PRINTF_BUFFER_SIZE: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_PREFERRED_INTEROP_USER_SYNC: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_PARENT_DEVICE: {
-        const ur_device_handle_t *tptr = (const ur_device_handle_t *)ptr;
-        if (sizeof(ur_device_handle_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_handle_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printPtr(os,
-                              *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_SUPPORTED_PARTITIONS: {
-
-        const ur_device_partition_t *tptr = (const ur_device_partition_t *)ptr;
-        os << "{";
-        size_t nelems = size / sizeof(ur_device_partition_t);
-        for (size_t i = 0; i < nelems; ++i) {
-            if (i != 0) {
-                os << ", ";
-            }
-
-            os << tptr[i];
-        }
-        os << "}";
-    } break;
-    case UR_DEVICE_INFO_PARTITION_MAX_SUB_DEVICES: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_PARTITION_AFFINITY_DOMAIN: {
-        const ur_device_affinity_domain_flags_t *tptr = (const ur_device_affinity_domain_flags_t *)ptr;
-        if (sizeof(ur_device_affinity_domain_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_affinity_domain_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_device_affinity_domain_flag_t>(os,
-                                                                 *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_PARTITION_TYPE: {
-
-        const ur_device_partition_property_t *tptr = (const ur_device_partition_property_t *)ptr;
-        os << "{";
-        size_t nelems = size / sizeof(ur_device_partition_property_t);
-        for (size_t i = 0; i < nelems; ++i) {
-            if (i != 0) {
-                os << ", ";
-            }
-
-            os << tptr[i];
-        }
-        os << "}";
-    } break;
-    case UR_DEVICE_INFO_MAX_NUM_SUB_GROUPS: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_SUB_GROUP_SIZES_INTEL: {
-
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        os << "{";
-        size_t nelems = size / sizeof(uint32_t);
-        for (size_t i = 0; i < nelems; ++i) {
-            if (i != 0) {
-                os << ", ";
-            }
-
-            os << tptr[i];
-        }
-        os << "}";
-    } break;
-    case UR_DEVICE_INFO_USM_HOST_SUPPORT: {
-        const ur_device_usm_access_capability_flags_t *tptr = (const ur_device_usm_access_capability_flags_t *)ptr;
-        if (sizeof(ur_device_usm_access_capability_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_usm_access_capability_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_device_usm_access_capability_flag_t>(os,
-                                                                       *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_USM_DEVICE_SUPPORT: {
-        const ur_device_usm_access_capability_flags_t *tptr = (const ur_device_usm_access_capability_flags_t *)ptr;
-        if (sizeof(ur_device_usm_access_capability_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_usm_access_capability_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_device_usm_access_capability_flag_t>(os,
-                                                                       *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_USM_SINGLE_SHARED_SUPPORT: {
-        const ur_device_usm_access_capability_flags_t *tptr = (const ur_device_usm_access_capability_flags_t *)ptr;
-        if (sizeof(ur_device_usm_access_capability_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_usm_access_capability_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_device_usm_access_capability_flag_t>(os,
-                                                                       *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_USM_CROSS_SHARED_SUPPORT: {
-        const ur_device_usm_access_capability_flags_t *tptr = (const ur_device_usm_access_capability_flags_t *)ptr;
-        if (sizeof(ur_device_usm_access_capability_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_usm_access_capability_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_device_usm_access_capability_flag_t>(os,
-                                                                       *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_USM_SYSTEM_SHARED_SUPPORT: {
-        const ur_device_usm_access_capability_flags_t *tptr = (const ur_device_usm_access_capability_flags_t *)ptr;
-        if (sizeof(ur_device_usm_access_capability_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_usm_access_capability_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_device_usm_access_capability_flag_t>(os,
-                                                                       *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_UUID: {
-
-        const uint8_t *tptr = (const uint8_t *)ptr;
-        os << "{";
-        size_t nelems = size / sizeof(uint8_t);
-        for (size_t i = 0; i < nelems; ++i) {
-            if (i != 0) {
-                os << ", ";
-            }
-
-            os << tptr[i];
-        }
-        os << "}";
-    } break;
-    case UR_DEVICE_INFO_PCI_ADDRESS: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_DEVICE_INFO_GPU_EU_COUNT: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_GPU_EU_SIMD_WIDTH: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_GPU_EU_SLICES: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_GPU_EU_COUNT_PER_SUBSLICE: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_GPU_SUBSLICES_PER_SLICE: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_GPU_HW_THREADS_PER_EU: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MAX_MEMORY_BANDWIDTH: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_IMAGE_SRGB: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_BUILD_ON_SUBDEVICE: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_ATOMIC_64: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_ATOMIC_MEMORY_ORDER_CAPABILITIES: {
-        const ur_memory_order_capability_flags_t *tptr = (const ur_memory_order_capability_flags_t *)ptr;
-        if (sizeof(ur_memory_order_capability_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_memory_order_capability_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_memory_order_capability_flag_t>(os,
-                                                                  *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_ATOMIC_MEMORY_SCOPE_CAPABILITIES: {
-        const ur_memory_scope_capability_flags_t *tptr = (const ur_memory_scope_capability_flags_t *)ptr;
-        if (sizeof(ur_memory_scope_capability_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_memory_scope_capability_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_memory_scope_capability_flag_t>(os,
-                                                                  *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_ATOMIC_FENCE_ORDER_CAPABILITIES: {
-        const ur_memory_order_capability_flags_t *tptr = (const ur_memory_order_capability_flags_t *)ptr;
-        if (sizeof(ur_memory_order_capability_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_memory_order_capability_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_memory_order_capability_flag_t>(os,
-                                                                  *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_ATOMIC_FENCE_SCOPE_CAPABILITIES: {
-        const ur_memory_scope_capability_flags_t *tptr = (const ur_memory_scope_capability_flags_t *)ptr;
-        if (sizeof(ur_memory_scope_capability_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_memory_scope_capability_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_memory_scope_capability_flag_t>(os,
-                                                                  *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_BFLOAT16: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MAX_COMPUTE_QUEUE_INDICES: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_KERNEL_SET_SPECIALIZATION_CONSTANTS: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MEMORY_BUS_WIDTH: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MAX_WORK_GROUPS_3D: {
-
-        const size_t *tptr = (const size_t *)ptr;
-        os << "{";
-        size_t nelems = size / sizeof(size_t);
-        for (size_t i = 0; i < nelems; ++i) {
-            if (i != 0) {
-                os << ", ";
-            }
-
-            os << tptr[i];
-        }
-        os << "}";
-    } break;
-    case UR_DEVICE_INFO_ASYNC_BARRIER: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MEM_CHANNEL_SUPPORT: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_HOST_PIPE_READ_WRITE_SUPPORTED: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MAX_REGISTERS_PER_WORK_GROUP: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_IP_VERSION: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_VIRTUAL_MEMORY_SUPPORT: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_ESIMD_SUPPORT: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_COMPONENT_DEVICES: {
-
-        const ur_device_handle_t *tptr = (const ur_device_handle_t *)ptr;
-        os << "{";
-        size_t nelems = size / sizeof(ur_device_handle_t);
-        for (size_t i = 0; i < nelems; ++i) {
-            if (i != 0) {
-                os << ", ";
-            }
-
-            ur::details::printPtr(os,
-                                  tptr[i]);
-        }
-        os << "}";
-    } break;
-    case UR_DEVICE_INFO_COMPOSITE_DEVICE: {
-        const ur_device_handle_t *tptr = (const ur_device_handle_t *)ptr;
-        if (sizeof(ur_device_handle_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_handle_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printPtr(os,
-                              *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_GLOBAL_VARIABLE_SUPPORT: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_COMMAND_BUFFER_SUPPORT_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_COMMAND_BUFFER_UPDATE_CAPABILITIES_EXP: {
-        const ur_device_command_buffer_update_capability_flags_t *tptr = (const ur_device_command_buffer_update_capability_flags_t *)ptr;
-        if (sizeof(ur_device_command_buffer_update_capability_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_command_buffer_update_capability_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_device_command_buffer_update_capability_flag_t>(os,
-                                                                                  *tptr);
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_CLUSTER_LAUNCH_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_BINDLESS_IMAGES_SUPPORT_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_BINDLESS_IMAGES_SHARED_USM_SUPPORT_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_BINDLESS_IMAGES_1D_USM_SUPPORT_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_BINDLESS_IMAGES_2D_USM_SUPPORT_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_IMAGE_PITCH_ALIGN_EXP: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MAX_IMAGE_LINEAR_WIDTH_EXP: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MAX_IMAGE_LINEAR_HEIGHT_EXP: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MAX_IMAGE_LINEAR_PITCH_EXP: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MIPMAP_SUPPORT_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MIPMAP_ANISOTROPY_SUPPORT_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MIPMAP_MAX_ANISOTROPY_EXP: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_MIPMAP_LEVEL_REFERENCE_SUPPORT_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_EXTERNAL_MEMORY_IMPORT_SUPPORT_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_EXTERNAL_SEMAPHORE_IMPORT_SUPPORT_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_CUBEMAP_SUPPORT_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_CUBEMAP_SEAMLESS_FILTERING_SUPPORT_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_USM_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_USM_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_3D_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_TIMESTAMP_RECORDING_SUPPORT_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_IMAGE_ARRAY_SUPPORT_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_BINDLESS_UNIQUE_ADDRESSING_PER_DIM_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_BINDLESS_SAMPLE_1D_USM_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_BINDLESS_SAMPLE_2D_USM_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_DEVICE_INFO_ENQUEUE_NATIVE_COMMAND_SUPPORT_EXP: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_device_affinity_domain_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_affinity_domain_flag_t value) {
-    switch (value) {
-    case UR_DEVICE_AFFINITY_DOMAIN_FLAG_NUMA:
-        os << "UR_DEVICE_AFFINITY_DOMAIN_FLAG_NUMA";
-        break;
-    case UR_DEVICE_AFFINITY_DOMAIN_FLAG_L4_CACHE:
-        os << "UR_DEVICE_AFFINITY_DOMAIN_FLAG_L4_CACHE";
-        break;
-    case UR_DEVICE_AFFINITY_DOMAIN_FLAG_L3_CACHE:
-        os << "UR_DEVICE_AFFINITY_DOMAIN_FLAG_L3_CACHE";
-        break;
-    case UR_DEVICE_AFFINITY_DOMAIN_FLAG_L2_CACHE:
-        os << "UR_DEVICE_AFFINITY_DOMAIN_FLAG_L2_CACHE";
-        break;
-    case UR_DEVICE_AFFINITY_DOMAIN_FLAG_L1_CACHE:
-        os << "UR_DEVICE_AFFINITY_DOMAIN_FLAG_L1_CACHE";
-        break;
-    case UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE:
-        os << "UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_device_affinity_domain_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_device_affinity_domain_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_DEVICE_AFFINITY_DOMAIN_FLAG_NUMA) == (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_NUMA) {
-        val ^= (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_NUMA;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_AFFINITY_DOMAIN_FLAG_NUMA;
-    }
-
-    if ((val & UR_DEVICE_AFFINITY_DOMAIN_FLAG_L4_CACHE) == (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_L4_CACHE) {
-        val ^= (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_L4_CACHE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_AFFINITY_DOMAIN_FLAG_L4_CACHE;
-    }
-
-    if ((val & UR_DEVICE_AFFINITY_DOMAIN_FLAG_L3_CACHE) == (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_L3_CACHE) {
-        val ^= (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_L3_CACHE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_AFFINITY_DOMAIN_FLAG_L3_CACHE;
-    }
-
-    if ((val & UR_DEVICE_AFFINITY_DOMAIN_FLAG_L2_CACHE) == (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_L2_CACHE) {
-        val ^= (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_L2_CACHE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_AFFINITY_DOMAIN_FLAG_L2_CACHE;
-    }
-
-    if ((val & UR_DEVICE_AFFINITY_DOMAIN_FLAG_L1_CACHE) == (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_L1_CACHE) {
-        val ^= (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_L1_CACHE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_AFFINITY_DOMAIN_FLAG_L1_CACHE;
-    }
-
-    if ((val & UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE) == (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE) {
-        val ^= (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_device_partition_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_partition_t value) {
-    switch (value) {
-    case UR_DEVICE_PARTITION_EQUALLY:
-        os << "UR_DEVICE_PARTITION_EQUALLY";
-        break;
-    case UR_DEVICE_PARTITION_BY_COUNTS:
-        os << "UR_DEVICE_PARTITION_BY_COUNTS";
-        break;
-    case UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN:
-        os << "UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN";
-        break;
-    case UR_DEVICE_PARTITION_BY_CSLICE:
-        os << "UR_DEVICE_PARTITION_BY_CSLICE";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-
-///////////////////////////////////////////////////////////////////////////////
-// @brief Print ur_device_partition_value_t union
-inline ur_result_t printUnion(
-    std::ostream &os,
-    const union ur_device_partition_value_t params,
-    const enum ur_device_partition_t tag) {
-    os << "(union ur_device_partition_value_t){";
-
-    switch (tag) {
-    case UR_DEVICE_PARTITION_EQUALLY:
-
-        os << ".equally = ";
-
-        os << (params.equally);
-
-        break;
-    case UR_DEVICE_PARTITION_BY_COUNTS:
-
-        os << ".count = ";
-
-        os << (params.count);
-
-        break;
-    case UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN:
-
-        os << ".affinity_domain = ";
-
-        ur::details::printFlag<ur_device_affinity_domain_flag_t>(os,
-                                                                 (params.affinity_domain));
-
-        break;
-    default:
-        os << "<unknown>";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    os << "}";
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_device_partition_property_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_device_partition_property_t params) {
-    os << "(struct ur_device_partition_property_t){";
-
-    os << ".type = ";
-
-    os << (params.type);
-
-    os << ", ";
-    os << ".value = ";
-    ur::details::printUnion(os, (params.value), params.type);
-
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_device_partition_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_device_partition_properties_t params) {
-    os << "(struct ur_device_partition_properties_t){";
-
-    os << ".stype = ";
-
-    os << (params.stype);
-
-    os << ", ";
-    os << ".pNext = ";
-
-    ur::details::printStruct(os,
-                             (params.pNext));
-
-    os << ", ";
-    os << ".pProperties = ";
-
-    ur::details::printPtr(os,
-                          (params.pProperties));
-
-    os << ", ";
-    os << ".PropCount = ";
-
-    os << (params.PropCount);
-
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_device_fp_capability_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_fp_capability_flag_t value) {
-    switch (value) {
-    case UR_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT:
-        os << "UR_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT";
-        break;
-    case UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST:
-        os << "UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST";
-        break;
-    case UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO:
-        os << "UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO";
-        break;
-    case UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF:
-        os << "UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF";
-        break;
-    case UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN:
-        os << "UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN";
-        break;
-    case UR_DEVICE_FP_CAPABILITY_FLAG_DENORM:
-        os << "UR_DEVICE_FP_CAPABILITY_FLAG_DENORM";
-        break;
-    case UR_DEVICE_FP_CAPABILITY_FLAG_FMA:
-        os << "UR_DEVICE_FP_CAPABILITY_FLAG_FMA";
-        break;
-    case UR_DEVICE_FP_CAPABILITY_FLAG_SOFT_FLOAT:
-        os << "UR_DEVICE_FP_CAPABILITY_FLAG_SOFT_FLOAT";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_device_fp_capability_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_device_fp_capability_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT) == (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT) {
-        val ^= (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT;
-    }
-
-    if ((val & UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST) == (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST) {
-        val ^= (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST;
-    }
-
-    if ((val & UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO) == (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO) {
-        val ^= (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO;
-    }
-
-    if ((val & UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF) == (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF) {
-        val ^= (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF;
-    }
-
-    if ((val & UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN) == (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN) {
-        val ^= (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN;
-    }
-
-    if ((val & UR_DEVICE_FP_CAPABILITY_FLAG_DENORM) == (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_DENORM) {
-        val ^= (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_DENORM;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_FP_CAPABILITY_FLAG_DENORM;
-    }
-
-    if ((val & UR_DEVICE_FP_CAPABILITY_FLAG_FMA) == (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_FMA) {
-        val ^= (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_FMA;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_FP_CAPABILITY_FLAG_FMA;
-    }
-
-    if ((val & UR_DEVICE_FP_CAPABILITY_FLAG_SOFT_FLOAT) == (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_SOFT_FLOAT) {
-        val ^= (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_SOFT_FLOAT;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_FP_CAPABILITY_FLAG_SOFT_FLOAT;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_device_mem_cache_type_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_mem_cache_type_t value) {
-    switch (value) {
-    case UR_DEVICE_MEM_CACHE_TYPE_NONE:
-        os << "UR_DEVICE_MEM_CACHE_TYPE_NONE";
-        break;
-    case UR_DEVICE_MEM_CACHE_TYPE_READ_ONLY_CACHE:
-        os << "UR_DEVICE_MEM_CACHE_TYPE_READ_ONLY_CACHE";
-        break;
-    case UR_DEVICE_MEM_CACHE_TYPE_READ_WRITE_CACHE:
-        os << "UR_DEVICE_MEM_CACHE_TYPE_READ_WRITE_CACHE";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_device_local_mem_type_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_local_mem_type_t value) {
-    switch (value) {
-    case UR_DEVICE_LOCAL_MEM_TYPE_NONE:
-        os << "UR_DEVICE_LOCAL_MEM_TYPE_NONE";
-        break;
-    case UR_DEVICE_LOCAL_MEM_TYPE_LOCAL:
-        os << "UR_DEVICE_LOCAL_MEM_TYPE_LOCAL";
-        break;
-    case UR_DEVICE_LOCAL_MEM_TYPE_GLOBAL:
-        os << "UR_DEVICE_LOCAL_MEM_TYPE_GLOBAL";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_device_exec_capability_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_exec_capability_flag_t value) {
-    switch (value) {
-    case UR_DEVICE_EXEC_CAPABILITY_FLAG_KERNEL:
-        os << "UR_DEVICE_EXEC_CAPABILITY_FLAG_KERNEL";
-        break;
-    case UR_DEVICE_EXEC_CAPABILITY_FLAG_NATIVE_KERNEL:
-        os << "UR_DEVICE_EXEC_CAPABILITY_FLAG_NATIVE_KERNEL";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_device_exec_capability_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_device_exec_capability_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_DEVICE_EXEC_CAPABILITY_FLAG_KERNEL) == (uint32_t)UR_DEVICE_EXEC_CAPABILITY_FLAG_KERNEL) {
-        val ^= (uint32_t)UR_DEVICE_EXEC_CAPABILITY_FLAG_KERNEL;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_EXEC_CAPABILITY_FLAG_KERNEL;
-    }
-
-    if ((val & UR_DEVICE_EXEC_CAPABILITY_FLAG_NATIVE_KERNEL) == (uint32_t)UR_DEVICE_EXEC_CAPABILITY_FLAG_NATIVE_KERNEL) {
-        val ^= (uint32_t)UR_DEVICE_EXEC_CAPABILITY_FLAG_NATIVE_KERNEL;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_EXEC_CAPABILITY_FLAG_NATIVE_KERNEL;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_device_native_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_device_native_properties_t params) {
-    os << "(struct ur_device_native_properties_t){";
-
-    os << ".stype = ";
-
-    os << (params.stype);
-
-    os << ", ";
-    os << ".pNext = ";
-
-    ur::details::printStruct(os,
-                             (params.pNext));
-
-    os << ", ";
-    os << ".isNativeHandleOwned = ";
-
-    os << (params.isNativeHandleOwned);
-
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_memory_order_capability_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_memory_order_capability_flag_t value) {
-    switch (value) {
-    case UR_MEMORY_ORDER_CAPABILITY_FLAG_RELAXED:
-        os << "UR_MEMORY_ORDER_CAPABILITY_FLAG_RELAXED";
-        break;
-    case UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQUIRE:
-        os << "UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQUIRE";
-        break;
-    case UR_MEMORY_ORDER_CAPABILITY_FLAG_RELEASE:
-        os << "UR_MEMORY_ORDER_CAPABILITY_FLAG_RELEASE";
-        break;
-    case UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQ_REL:
-        os << "UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQ_REL";
-        break;
-    case UR_MEMORY_ORDER_CAPABILITY_FLAG_SEQ_CST:
-        os << "UR_MEMORY_ORDER_CAPABILITY_FLAG_SEQ_CST";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_memory_order_capability_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_memory_order_capability_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_MEMORY_ORDER_CAPABILITY_FLAG_RELAXED) == (uint32_t)UR_MEMORY_ORDER_CAPABILITY_FLAG_RELAXED) {
-        val ^= (uint32_t)UR_MEMORY_ORDER_CAPABILITY_FLAG_RELAXED;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_MEMORY_ORDER_CAPABILITY_FLAG_RELAXED;
-    }
-
-    if ((val & UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQUIRE) == (uint32_t)UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQUIRE) {
-        val ^= (uint32_t)UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQUIRE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQUIRE;
-    }
-
-    if ((val & UR_MEMORY_ORDER_CAPABILITY_FLAG_RELEASE) == (uint32_t)UR_MEMORY_ORDER_CAPABILITY_FLAG_RELEASE) {
-        val ^= (uint32_t)UR_MEMORY_ORDER_CAPABILITY_FLAG_RELEASE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_MEMORY_ORDER_CAPABILITY_FLAG_RELEASE;
-    }
-
-    if ((val & UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQ_REL) == (uint32_t)UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQ_REL) {
-        val ^= (uint32_t)UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQ_REL;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQ_REL;
-    }
-
-    if ((val & UR_MEMORY_ORDER_CAPABILITY_FLAG_SEQ_CST) == (uint32_t)UR_MEMORY_ORDER_CAPABILITY_FLAG_SEQ_CST) {
-        val ^= (uint32_t)UR_MEMORY_ORDER_CAPABILITY_FLAG_SEQ_CST;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_MEMORY_ORDER_CAPABILITY_FLAG_SEQ_CST;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_memory_scope_capability_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_memory_scope_capability_flag_t value) {
-    switch (value) {
-    case UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_ITEM:
-        os << "UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_ITEM";
-        break;
-    case UR_MEMORY_SCOPE_CAPABILITY_FLAG_SUB_GROUP:
-        os << "UR_MEMORY_SCOPE_CAPABILITY_FLAG_SUB_GROUP";
-        break;
-    case UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_GROUP:
-        os << "UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_GROUP";
-        break;
-    case UR_MEMORY_SCOPE_CAPABILITY_FLAG_DEVICE:
-        os << "UR_MEMORY_SCOPE_CAPABILITY_FLAG_DEVICE";
-        break;
-    case UR_MEMORY_SCOPE_CAPABILITY_FLAG_SYSTEM:
-        os << "UR_MEMORY_SCOPE_CAPABILITY_FLAG_SYSTEM";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_memory_scope_capability_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_memory_scope_capability_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_ITEM) == (uint32_t)UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_ITEM) {
-        val ^= (uint32_t)UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_ITEM;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_ITEM;
-    }
-
-    if ((val & UR_MEMORY_SCOPE_CAPABILITY_FLAG_SUB_GROUP) == (uint32_t)UR_MEMORY_SCOPE_CAPABILITY_FLAG_SUB_GROUP) {
-        val ^= (uint32_t)UR_MEMORY_SCOPE_CAPABILITY_FLAG_SUB_GROUP;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_MEMORY_SCOPE_CAPABILITY_FLAG_SUB_GROUP;
-    }
-
-    if ((val & UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_GROUP) == (uint32_t)UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_GROUP) {
-        val ^= (uint32_t)UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_GROUP;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_GROUP;
-    }
-
-    if ((val & UR_MEMORY_SCOPE_CAPABILITY_FLAG_DEVICE) == (uint32_t)UR_MEMORY_SCOPE_CAPABILITY_FLAG_DEVICE) {
-        val ^= (uint32_t)UR_MEMORY_SCOPE_CAPABILITY_FLAG_DEVICE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_MEMORY_SCOPE_CAPABILITY_FLAG_DEVICE;
-    }
-
-    if ((val & UR_MEMORY_SCOPE_CAPABILITY_FLAG_SYSTEM) == (uint32_t)UR_MEMORY_SCOPE_CAPABILITY_FLAG_SYSTEM) {
-        val ^= (uint32_t)UR_MEMORY_SCOPE_CAPABILITY_FLAG_SYSTEM;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_MEMORY_SCOPE_CAPABILITY_FLAG_SYSTEM;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_device_usm_access_capability_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_usm_access_capability_flag_t value) {
-    switch (value) {
-    case UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ACCESS:
-        os << "UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ACCESS";
-        break;
-    case UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_ACCESS:
-        os << "UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_ACCESS";
-        break;
-    case UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_CONCURRENT_ACCESS:
-        os << "UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_CONCURRENT_ACCESS";
-        break;
-    case UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_CONCURRENT_ACCESS:
-        os << "UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_CONCURRENT_ACCESS";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_device_usm_access_capability_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_device_usm_access_capability_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ACCESS) == (uint32_t)UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ACCESS) {
-        val ^= (uint32_t)UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ACCESS;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ACCESS;
-    }
-
-    if ((val & UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_ACCESS) == (uint32_t)UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_ACCESS) {
-        val ^= (uint32_t)UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_ACCESS;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_ACCESS;
-    }
-
-    if ((val & UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_CONCURRENT_ACCESS) == (uint32_t)UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_CONCURRENT_ACCESS) {
-        val ^= (uint32_t)UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_CONCURRENT_ACCESS;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_CONCURRENT_ACCESS;
-    }
-
-    if ((val & UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_CONCURRENT_ACCESS) == (uint32_t)UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_CONCURRENT_ACCESS) {
-        val ^= (uint32_t)UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_CONCURRENT_ACCESS;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_CONCURRENT_ACCESS;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_context_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_context_flag_t value) {
-    switch (value) {
-    case UR_CONTEXT_FLAG_TBD:
-        os << "UR_CONTEXT_FLAG_TBD";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_context_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_context_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_CONTEXT_FLAG_TBD) == (uint32_t)UR_CONTEXT_FLAG_TBD) {
-        val ^= (uint32_t)UR_CONTEXT_FLAG_TBD;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_CONTEXT_FLAG_TBD;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_context_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_context_properties_t params) {
-    os << "(struct ur_context_properties_t){";
-
-    os << ".stype = ";
-
-    os << (params.stype);
-
-    os << ", ";
-    os << ".pNext = ";
-
-    ur::details::printStruct(os,
-                             (params.pNext));
-
-    os << ", ";
-    os << ".flags = ";
-
-    ur::details::printFlag<ur_context_flag_t>(os,
-                                              (params.flags));
-
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_context_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_context_info_t value) {
-    switch (value) {
-    case UR_CONTEXT_INFO_NUM_DEVICES:
-        os << "UR_CONTEXT_INFO_NUM_DEVICES";
-        break;
-    case UR_CONTEXT_INFO_DEVICES:
-        os << "UR_CONTEXT_INFO_DEVICES";
-        break;
-    case UR_CONTEXT_INFO_REFERENCE_COUNT:
-        os << "UR_CONTEXT_INFO_REFERENCE_COUNT";
-        break;
-    case UR_CONTEXT_INFO_USM_MEMCPY2D_SUPPORT:
-        os << "UR_CONTEXT_INFO_USM_MEMCPY2D_SUPPORT";
-        break;
-    case UR_CONTEXT_INFO_USM_FILL2D_SUPPORT:
-        os << "UR_CONTEXT_INFO_USM_FILL2D_SUPPORT";
-        break;
-    case UR_CONTEXT_INFO_ATOMIC_MEMORY_ORDER_CAPABILITIES:
-        os << "UR_CONTEXT_INFO_ATOMIC_MEMORY_ORDER_CAPABILITIES";
-        break;
-    case UR_CONTEXT_INFO_ATOMIC_MEMORY_SCOPE_CAPABILITIES:
-        os << "UR_CONTEXT_INFO_ATOMIC_MEMORY_SCOPE_CAPABILITIES";
-        break;
-    case UR_CONTEXT_INFO_ATOMIC_FENCE_ORDER_CAPABILITIES:
-        os << "UR_CONTEXT_INFO_ATOMIC_FENCE_ORDER_CAPABILITIES";
-        break;
-    case UR_CONTEXT_INFO_ATOMIC_FENCE_SCOPE_CAPABILITIES:
-        os << "UR_CONTEXT_INFO_ATOMIC_FENCE_SCOPE_CAPABILITIES";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_context_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_context_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
-
-    switch (value) {
-    case UR_CONTEXT_INFO_NUM_DEVICES: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_CONTEXT_INFO_DEVICES: {
-
-        const ur_device_handle_t *tptr = (const ur_device_handle_t *)ptr;
-        os << "{";
-        size_t nelems = size / sizeof(ur_device_handle_t);
-        for (size_t i = 0; i < nelems; ++i) {
-            if (i != 0) {
-                os << ", ";
-            }
-
-            ur::details::printPtr(os,
-                                  tptr[i]);
-        }
-        os << "}";
-    } break;
-    case UR_CONTEXT_INFO_REFERENCE_COUNT: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_CONTEXT_INFO_USM_MEMCPY2D_SUPPORT: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_CONTEXT_INFO_USM_FILL2D_SUPPORT: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_CONTEXT_INFO_ATOMIC_MEMORY_ORDER_CAPABILITIES: {
-        const ur_memory_order_capability_flags_t *tptr = (const ur_memory_order_capability_flags_t *)ptr;
-        if (sizeof(ur_memory_order_capability_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_memory_order_capability_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_memory_order_capability_flag_t>(os,
-                                                                  *tptr);
-
-        os << ")";
-    } break;
-    case UR_CONTEXT_INFO_ATOMIC_MEMORY_SCOPE_CAPABILITIES: {
-        const ur_memory_scope_capability_flags_t *tptr = (const ur_memory_scope_capability_flags_t *)ptr;
-        if (sizeof(ur_memory_scope_capability_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_memory_scope_capability_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_memory_scope_capability_flag_t>(os,
-                                                                  *tptr);
-
-        os << ")";
-    } break;
-    case UR_CONTEXT_INFO_ATOMIC_FENCE_ORDER_CAPABILITIES: {
-        const ur_memory_order_capability_flags_t *tptr = (const ur_memory_order_capability_flags_t *)ptr;
-        if (sizeof(ur_memory_order_capability_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_memory_order_capability_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_memory_order_capability_flag_t>(os,
-                                                                  *tptr);
-
-        os << ")";
-    } break;
-    case UR_CONTEXT_INFO_ATOMIC_FENCE_SCOPE_CAPABILITIES: {
-        const ur_memory_scope_capability_flags_t *tptr = (const ur_memory_scope_capability_flags_t *)ptr;
-        if (sizeof(ur_memory_scope_capability_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_memory_scope_capability_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printFlag<ur_memory_scope_capability_flag_t>(os,
-                                                                  *tptr);
-
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_context_native_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_context_native_properties_t params) {
-    os << "(struct ur_context_native_properties_t){";
-
-    os << ".stype = ";
-
-    os << (params.stype);
-
-    os << ", ";
-    os << ".pNext = ";
-
-    ur::details::printStruct(os,
-                             (params.pNext));
-
-    os << ", ";
-    os << ".isNativeHandleOwned = ";
-
-    os << (params.isNativeHandleOwned);
-
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_mem_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_mem_flag_t value) {
-    switch (value) {
-    case UR_MEM_FLAG_READ_WRITE:
-        os << "UR_MEM_FLAG_READ_WRITE";
-        break;
-    case UR_MEM_FLAG_WRITE_ONLY:
-        os << "UR_MEM_FLAG_WRITE_ONLY";
-        break;
-    case UR_MEM_FLAG_READ_ONLY:
-        os << "UR_MEM_FLAG_READ_ONLY";
-        break;
-    case UR_MEM_FLAG_USE_HOST_POINTER:
-        os << "UR_MEM_FLAG_USE_HOST_POINTER";
-        break;
-    case UR_MEM_FLAG_ALLOC_HOST_POINTER:
-        os << "UR_MEM_FLAG_ALLOC_HOST_POINTER";
-        break;
-    case UR_MEM_FLAG_ALLOC_COPY_HOST_POINTER:
-        os << "UR_MEM_FLAG_ALLOC_COPY_HOST_POINTER";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_mem_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_mem_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_MEM_FLAG_READ_WRITE) == (uint32_t)UR_MEM_FLAG_READ_WRITE) {
-        val ^= (uint32_t)UR_MEM_FLAG_READ_WRITE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_MEM_FLAG_READ_WRITE;
-    }
-
-    if ((val & UR_MEM_FLAG_WRITE_ONLY) == (uint32_t)UR_MEM_FLAG_WRITE_ONLY) {
-        val ^= (uint32_t)UR_MEM_FLAG_WRITE_ONLY;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_MEM_FLAG_WRITE_ONLY;
-    }
-
-    if ((val & UR_MEM_FLAG_READ_ONLY) == (uint32_t)UR_MEM_FLAG_READ_ONLY) {
-        val ^= (uint32_t)UR_MEM_FLAG_READ_ONLY;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_MEM_FLAG_READ_ONLY;
-    }
-
-    if ((val & UR_MEM_FLAG_USE_HOST_POINTER) == (uint32_t)UR_MEM_FLAG_USE_HOST_POINTER) {
-        val ^= (uint32_t)UR_MEM_FLAG_USE_HOST_POINTER;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_MEM_FLAG_USE_HOST_POINTER;
-    }
-
-    if ((val & UR_MEM_FLAG_ALLOC_HOST_POINTER) == (uint32_t)UR_MEM_FLAG_ALLOC_HOST_POINTER) {
-        val ^= (uint32_t)UR_MEM_FLAG_ALLOC_HOST_POINTER;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_MEM_FLAG_ALLOC_HOST_POINTER;
-    }
-
-    if ((val & UR_MEM_FLAG_ALLOC_COPY_HOST_POINTER) == (uint32_t)UR_MEM_FLAG_ALLOC_COPY_HOST_POINTER) {
-        val ^= (uint32_t)UR_MEM_FLAG_ALLOC_COPY_HOST_POINTER;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_MEM_FLAG_ALLOC_COPY_HOST_POINTER;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_mem_type_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_mem_type_t value) {
-    switch (value) {
-    case UR_MEM_TYPE_IMAGE2D:
-        os << "UR_MEM_TYPE_IMAGE2D";
-        break;
-    case UR_MEM_TYPE_IMAGE3D:
-        os << "UR_MEM_TYPE_IMAGE3D";
-        break;
-    case UR_MEM_TYPE_IMAGE2D_ARRAY:
-        os << "UR_MEM_TYPE_IMAGE2D_ARRAY";
-        break;
-    case UR_MEM_TYPE_IMAGE1D:
-        os << "UR_MEM_TYPE_IMAGE1D";
-        break;
-    case UR_MEM_TYPE_IMAGE1D_ARRAY:
-        os << "UR_MEM_TYPE_IMAGE1D_ARRAY";
-        break;
-    case UR_MEM_TYPE_IMAGE_CUBEMAP_EXP:
-        os << "UR_MEM_TYPE_IMAGE_CUBEMAP_EXP";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_mem_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_mem_info_t value) {
-    switch (value) {
-    case UR_MEM_INFO_SIZE:
-        os << "UR_MEM_INFO_SIZE";
-        break;
-    case UR_MEM_INFO_CONTEXT:
-        os << "UR_MEM_INFO_CONTEXT";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_mem_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_mem_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
-
-    switch (value) {
-    case UR_MEM_INFO_SIZE: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_MEM_INFO_CONTEXT: {
-        const ur_context_handle_t *tptr = (const ur_context_handle_t *)ptr;
-        if (sizeof(ur_context_handle_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_context_handle_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printPtr(os,
-                              *tptr);
-
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_image_channel_order_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_image_channel_order_t value) {
-    switch (value) {
-    case UR_IMAGE_CHANNEL_ORDER_A:
-        os << "UR_IMAGE_CHANNEL_ORDER_A";
-        break;
-    case UR_IMAGE_CHANNEL_ORDER_R:
-        os << "UR_IMAGE_CHANNEL_ORDER_R";
-        break;
-    case UR_IMAGE_CHANNEL_ORDER_RG:
-        os << "UR_IMAGE_CHANNEL_ORDER_RG";
-        break;
-    case UR_IMAGE_CHANNEL_ORDER_RA:
-        os << "UR_IMAGE_CHANNEL_ORDER_RA";
-        break;
-    case UR_IMAGE_CHANNEL_ORDER_RGB:
-        os << "UR_IMAGE_CHANNEL_ORDER_RGB";
-        break;
-    case UR_IMAGE_CHANNEL_ORDER_RGBA:
-        os << "UR_IMAGE_CHANNEL_ORDER_RGBA";
-        break;
-    case UR_IMAGE_CHANNEL_ORDER_BGRA:
-        os << "UR_IMAGE_CHANNEL_ORDER_BGRA";
-        break;
-    case UR_IMAGE_CHANNEL_ORDER_ARGB:
-        os << "UR_IMAGE_CHANNEL_ORDER_ARGB";
-        break;
-    case UR_IMAGE_CHANNEL_ORDER_ABGR:
-        os << "UR_IMAGE_CHANNEL_ORDER_ABGR";
-        break;
-    case UR_IMAGE_CHANNEL_ORDER_INTENSITY:
-        os << "UR_IMAGE_CHANNEL_ORDER_INTENSITY";
-        break;
-    case UR_IMAGE_CHANNEL_ORDER_LUMINANCE:
-        os << "UR_IMAGE_CHANNEL_ORDER_LUMINANCE";
-        break;
-    case UR_IMAGE_CHANNEL_ORDER_RX:
-        os << "UR_IMAGE_CHANNEL_ORDER_RX";
-        break;
-    case UR_IMAGE_CHANNEL_ORDER_RGX:
-        os << "UR_IMAGE_CHANNEL_ORDER_RGX";
-        break;
-    case UR_IMAGE_CHANNEL_ORDER_RGBX:
-        os << "UR_IMAGE_CHANNEL_ORDER_RGBX";
-        break;
-    case UR_IMAGE_CHANNEL_ORDER_SRGBA:
-        os << "UR_IMAGE_CHANNEL_ORDER_SRGBA";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_image_channel_type_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_image_channel_type_t value) {
-    switch (value) {
-    case UR_IMAGE_CHANNEL_TYPE_SNORM_INT8:
-        os << "UR_IMAGE_CHANNEL_TYPE_SNORM_INT8";
-        break;
-    case UR_IMAGE_CHANNEL_TYPE_SNORM_INT16:
-        os << "UR_IMAGE_CHANNEL_TYPE_SNORM_INT16";
-        break;
-    case UR_IMAGE_CHANNEL_TYPE_UNORM_INT8:
-        os << "UR_IMAGE_CHANNEL_TYPE_UNORM_INT8";
-        break;
-    case UR_IMAGE_CHANNEL_TYPE_UNORM_INT16:
-        os << "UR_IMAGE_CHANNEL_TYPE_UNORM_INT16";
-        break;
-    case UR_IMAGE_CHANNEL_TYPE_UNORM_SHORT_565:
-        os << "UR_IMAGE_CHANNEL_TYPE_UNORM_SHORT_565";
-        break;
-    case UR_IMAGE_CHANNEL_TYPE_UNORM_SHORT_555:
-        os << "UR_IMAGE_CHANNEL_TYPE_UNORM_SHORT_555";
-        break;
-    case UR_IMAGE_CHANNEL_TYPE_INT_101010:
-        os << "UR_IMAGE_CHANNEL_TYPE_INT_101010";
-        break;
-    case UR_IMAGE_CHANNEL_TYPE_SIGNED_INT8:
-        os << "UR_IMAGE_CHANNEL_TYPE_SIGNED_INT8";
-        break;
-    case UR_IMAGE_CHANNEL_TYPE_SIGNED_INT16:
-        os << "UR_IMAGE_CHANNEL_TYPE_SIGNED_INT16";
-        break;
-    case UR_IMAGE_CHANNEL_TYPE_SIGNED_INT32:
-        os << "UR_IMAGE_CHANNEL_TYPE_SIGNED_INT32";
-        break;
-    case UR_IMAGE_CHANNEL_TYPE_UNSIGNED_INT8:
-        os << "UR_IMAGE_CHANNEL_TYPE_UNSIGNED_INT8";
-        break;
-    case UR_IMAGE_CHANNEL_TYPE_UNSIGNED_INT16:
-        os << "UR_IMAGE_CHANNEL_TYPE_UNSIGNED_INT16";
-        break;
-    case UR_IMAGE_CHANNEL_TYPE_UNSIGNED_INT32:
-        os << "UR_IMAGE_CHANNEL_TYPE_UNSIGNED_INT32";
-        break;
-    case UR_IMAGE_CHANNEL_TYPE_HALF_FLOAT:
-        os << "UR_IMAGE_CHANNEL_TYPE_HALF_FLOAT";
-        break;
-    case UR_IMAGE_CHANNEL_TYPE_FLOAT:
-        os << "UR_IMAGE_CHANNEL_TYPE_FLOAT";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_image_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_image_info_t value) {
-    switch (value) {
-    case UR_IMAGE_INFO_FORMAT:
-        os << "UR_IMAGE_INFO_FORMAT";
-        break;
-    case UR_IMAGE_INFO_ELEMENT_SIZE:
-        os << "UR_IMAGE_INFO_ELEMENT_SIZE";
-        break;
-    case UR_IMAGE_INFO_ROW_PITCH:
-        os << "UR_IMAGE_INFO_ROW_PITCH";
-        break;
-    case UR_IMAGE_INFO_SLICE_PITCH:
-        os << "UR_IMAGE_INFO_SLICE_PITCH";
-        break;
-    case UR_IMAGE_INFO_WIDTH:
-        os << "UR_IMAGE_INFO_WIDTH";
-        break;
-    case UR_IMAGE_INFO_HEIGHT:
-        os << "UR_IMAGE_INFO_HEIGHT";
-        break;
-    case UR_IMAGE_INFO_DEPTH:
-        os << "UR_IMAGE_INFO_DEPTH";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_image_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_image_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
-
-    switch (value) {
-    case UR_IMAGE_INFO_FORMAT: {
-        const ur_image_format_t *tptr = (const ur_image_format_t *)ptr;
-        if (sizeof(ur_image_format_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_image_format_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_IMAGE_INFO_ELEMENT_SIZE: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_IMAGE_INFO_ROW_PITCH: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_IMAGE_INFO_SLICE_PITCH: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_IMAGE_INFO_WIDTH: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_IMAGE_INFO_HEIGHT: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_IMAGE_INFO_DEPTH: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_image_format_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_image_format_t params) {
-    os << "(struct ur_image_format_t){";
-
-    os << ".channelOrder = ";
-
-    os << (params.channelOrder);
-
-    os << ", ";
-    os << ".channelType = ";
-
-    os << (params.channelType);
-
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_image_desc_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_image_desc_t params) {
-    os << "(struct ur_image_desc_t){";
-
-    os << ".stype = ";
-
-    os << (params.stype);
-
-    os << ", ";
-    os << ".pNext = ";
-
-    ur::details::printStruct(os,
-                             (params.pNext));
-
-    os << ", ";
-    os << ".type = ";
-
-    os << (params.type);
-
-    os << ", ";
-    os << ".width = ";
-
-    os << (params.width);
-
-    os << ", ";
-    os << ".height = ";
-
-    os << (params.height);
-
-    os << ", ";
-    os << ".depth = ";
-
-    os << (params.depth);
-
-    os << ", ";
-    os << ".arraySize = ";
-
-    os << (params.arraySize);
-
-    os << ", ";
-    os << ".rowPitch = ";
-
-    os << (params.rowPitch);
-
-    os << ", ";
-    os << ".slicePitch = ";
-
-    os << (params.slicePitch);
-
-    os << ", ";
-    os << ".numMipLevel = ";
-
-    os << (params.numMipLevel);
-
-    os << ", ";
-    os << ".numSamples = ";
-
-    os << (params.numSamples);
-
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_buffer_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_buffer_properties_t params) {
-    os << "(struct ur_buffer_properties_t){";
-
-    os << ".stype = ";
-
-    os << (params.stype);
-
-    os << ", ";
-    os << ".pNext = ";
-
-    ur::details::printStruct(os,
-                             (params.pNext));
-
-    os << ", ";
-    os << ".pHost = ";
-
-    ur::details::printPtr(os,
-                          (params.pHost));
-
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_buffer_channel_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_buffer_channel_properties_t params) {
-    os << "(struct ur_buffer_channel_properties_t){";
-
-    os << ".stype = ";
-
-    os << (params.stype);
-
-    os << ", ";
-    os << ".pNext = ";
-
-    ur::details::printStruct(os,
-                             (params.pNext));
-
-    os << ", ";
-    os << ".channel = ";
-
-    os << (params.channel);
-
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_buffer_alloc_location_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_buffer_alloc_location_properties_t params) {
-    os << "(struct ur_buffer_alloc_location_properties_t){";
-
-    os << ".stype = ";
-
-    os << (params.stype);
-
-    os << ", ";
-    os << ".pNext = ";
-
-    ur::details::printStruct(os,
-                             (params.pNext));
-
-    os << ", ";
-    os << ".location = ";
-
-    os << (params.location);
-
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_buffer_region_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_buffer_region_t params) {
-    os << "(struct ur_buffer_region_t){";
-
-    os << ".stype = ";
-
-    os << (params.stype);
-
-    os << ", ";
-    os << ".pNext = ";
-
-    ur::details::printStruct(os,
-                             (params.pNext));
-
-    os << ", ";
-    os << ".origin = ";
-
-    os << (params.origin);
-
-    os << ", ";
-    os << ".size = ";
-
-    os << (params.size);
-
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_buffer_create_type_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_buffer_create_type_t value) {
-    switch (value) {
-    case UR_BUFFER_CREATE_TYPE_REGION:
-        os << "UR_BUFFER_CREATE_TYPE_REGION";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_mem_native_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_mem_native_properties_t params) {
-    os << "(struct ur_mem_native_properties_t){";
-
-    os << ".stype = ";
-
-    os << (params.stype);
-
-    os << ", ";
-    os << ".pNext = ";
-
-    ur::details::printStruct(os,
-                             (params.pNext));
-
-    os << ", ";
-    os << ".isNativeHandleOwned = ";
-
-    os << (params.isNativeHandleOwned);
-
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_sampler_filter_mode_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_sampler_filter_mode_t value) {
-    switch (value) {
-    case UR_SAMPLER_FILTER_MODE_NEAREST:
-        os << "UR_SAMPLER_FILTER_MODE_NEAREST";
-        break;
-    case UR_SAMPLER_FILTER_MODE_LINEAR:
-        os << "UR_SAMPLER_FILTER_MODE_LINEAR";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_sampler_addressing_mode_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_sampler_addressing_mode_t value) {
-    switch (value) {
-    case UR_SAMPLER_ADDRESSING_MODE_NONE:
-        os << "UR_SAMPLER_ADDRESSING_MODE_NONE";
-        break;
-    case UR_SAMPLER_ADDRESSING_MODE_CLAMP_TO_EDGE:
-        os << "UR_SAMPLER_ADDRESSING_MODE_CLAMP_TO_EDGE";
-        break;
-    case UR_SAMPLER_ADDRESSING_MODE_CLAMP:
-        os << "UR_SAMPLER_ADDRESSING_MODE_CLAMP";
-        break;
-    case UR_SAMPLER_ADDRESSING_MODE_REPEAT:
-        os << "UR_SAMPLER_ADDRESSING_MODE_REPEAT";
-        break;
-    case UR_SAMPLER_ADDRESSING_MODE_MIRRORED_REPEAT:
-        os << "UR_SAMPLER_ADDRESSING_MODE_MIRRORED_REPEAT";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_sampler_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_sampler_info_t value) {
-    switch (value) {
-    case UR_SAMPLER_INFO_REFERENCE_COUNT:
-        os << "UR_SAMPLER_INFO_REFERENCE_COUNT";
-        break;
-    case UR_SAMPLER_INFO_CONTEXT:
-        os << "UR_SAMPLER_INFO_CONTEXT";
-        break;
-    case UR_SAMPLER_INFO_NORMALIZED_COORDS:
-        os << "UR_SAMPLER_INFO_NORMALIZED_COORDS";
-        break;
-    case UR_SAMPLER_INFO_ADDRESSING_MODE:
-        os << "UR_SAMPLER_INFO_ADDRESSING_MODE";
-        break;
-    case UR_SAMPLER_INFO_FILTER_MODE:
-        os << "UR_SAMPLER_INFO_FILTER_MODE";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_sampler_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_sampler_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
-
-    switch (value) {
-    case UR_SAMPLER_INFO_REFERENCE_COUNT: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_SAMPLER_INFO_CONTEXT: {
-        const ur_context_handle_t *tptr = (const ur_context_handle_t *)ptr;
-        if (sizeof(ur_context_handle_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_context_handle_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        ur::details::printPtr(os,
-                              *tptr);
-
-        os << ")";
-    } break;
-    case UR_SAMPLER_INFO_NORMALIZED_COORDS: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_SAMPLER_INFO_ADDRESSING_MODE: {
-        const ur_sampler_addressing_mode_t *tptr = (const ur_sampler_addressing_mode_t *)ptr;
-        if (sizeof(ur_sampler_addressing_mode_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_sampler_addressing_mode_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    case UR_SAMPLER_INFO_FILTER_MODE: {
-        const ur_sampler_filter_mode_t *tptr = (const ur_sampler_filter_mode_t *)ptr;
-        if (sizeof(ur_sampler_filter_mode_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_sampler_filter_mode_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
-
-        os << *tptr;
-
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_sampler_desc_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_sampler_desc_t params) {
-    os << "(struct ur_sampler_desc_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".normalizedCoords = ";
 
-    os << (params.normalizedCoords);
 
-    os << ", ";
-    os << ".addressingMode = ";
 
-    os << (params.addressingMode);
 
-    os << ", ";
-    os << ".filterMode = ";
 
-    os << (params.filterMode);
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_sampler_native_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_sampler_native_properties_t params) {
-    os << "(struct ur_sampler_native_properties_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".isNativeHandleOwned = ";
 
-    os << (params.isNativeHandleOwned);
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_host_mem_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_usm_host_mem_flag_t value) {
-    switch (value) {
-    case UR_USM_HOST_MEM_FLAG_INITIAL_PLACEMENT:
-        os << "UR_USM_HOST_MEM_FLAG_INITIAL_PLACEMENT";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
 
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_usm_host_mem_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_usm_host_mem_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_USM_HOST_MEM_FLAG_INITIAL_PLACEMENT) == (uint32_t)UR_USM_HOST_MEM_FLAG_INITIAL_PLACEMENT) {
-        val ^= (uint32_t)UR_USM_HOST_MEM_FLAG_INITIAL_PLACEMENT;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_HOST_MEM_FLAG_INITIAL_PLACEMENT;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_device_mem_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_usm_device_mem_flag_t value) {
-    switch (value) {
-    case UR_USM_DEVICE_MEM_FLAG_WRITE_COMBINED:
-        os << "UR_USM_DEVICE_MEM_FLAG_WRITE_COMBINED";
-        break;
-    case UR_USM_DEVICE_MEM_FLAG_INITIAL_PLACEMENT:
-        os << "UR_USM_DEVICE_MEM_FLAG_INITIAL_PLACEMENT";
-        break;
-    case UR_USM_DEVICE_MEM_FLAG_DEVICE_READ_ONLY:
-        os << "UR_USM_DEVICE_MEM_FLAG_DEVICE_READ_ONLY";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
 
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_usm_device_mem_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_usm_device_mem_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_USM_DEVICE_MEM_FLAG_WRITE_COMBINED) == (uint32_t)UR_USM_DEVICE_MEM_FLAG_WRITE_COMBINED) {
-        val ^= (uint32_t)UR_USM_DEVICE_MEM_FLAG_WRITE_COMBINED;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_DEVICE_MEM_FLAG_WRITE_COMBINED;
-    }
 
-    if ((val & UR_USM_DEVICE_MEM_FLAG_INITIAL_PLACEMENT) == (uint32_t)UR_USM_DEVICE_MEM_FLAG_INITIAL_PLACEMENT) {
-        val ^= (uint32_t)UR_USM_DEVICE_MEM_FLAG_INITIAL_PLACEMENT;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_DEVICE_MEM_FLAG_INITIAL_PLACEMENT;
-    }
 
-    if ((val & UR_USM_DEVICE_MEM_FLAG_DEVICE_READ_ONLY) == (uint32_t)UR_USM_DEVICE_MEM_FLAG_DEVICE_READ_ONLY) {
-        val ^= (uint32_t)UR_USM_DEVICE_MEM_FLAG_DEVICE_READ_ONLY;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_DEVICE_MEM_FLAG_DEVICE_READ_ONLY;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_pool_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_usm_pool_flag_t value) {
-    switch (value) {
-    case UR_USM_POOL_FLAG_ZERO_INITIALIZE_BLOCK:
-        os << "UR_USM_POOL_FLAG_ZERO_INITIALIZE_BLOCK";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
 
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_usm_pool_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_usm_pool_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_USM_POOL_FLAG_ZERO_INITIALIZE_BLOCK) == (uint32_t)UR_USM_POOL_FLAG_ZERO_INITIALIZE_BLOCK) {
-        val ^= (uint32_t)UR_USM_POOL_FLAG_ZERO_INITIALIZE_BLOCK;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_POOL_FLAG_ZERO_INITIALIZE_BLOCK;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_type_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_usm_type_t value) {
-    switch (value) {
-    case UR_USM_TYPE_UNKNOWN:
-        os << "UR_USM_TYPE_UNKNOWN";
-        break;
-    case UR_USM_TYPE_HOST:
-        os << "UR_USM_TYPE_HOST";
-        break;
-    case UR_USM_TYPE_DEVICE:
-        os << "UR_USM_TYPE_DEVICE";
-        break;
-    case UR_USM_TYPE_SHARED:
-        os << "UR_USM_TYPE_SHARED";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_alloc_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_usm_alloc_info_t value) {
-    switch (value) {
-    case UR_USM_ALLOC_INFO_TYPE:
-        os << "UR_USM_ALLOC_INFO_TYPE";
-        break;
-    case UR_USM_ALLOC_INFO_BASE_PTR:
-        os << "UR_USM_ALLOC_INFO_BASE_PTR";
-        break;
-    case UR_USM_ALLOC_INFO_SIZE:
-        os << "UR_USM_ALLOC_INFO_SIZE";
-        break;
-    case UR_USM_ALLOC_INFO_DEVICE:
-        os << "UR_USM_ALLOC_INFO_DEVICE";
-        break;
-    case UR_USM_ALLOC_INFO_POOL:
-        os << "UR_USM_ALLOC_INFO_POOL";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_usm_alloc_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_usm_alloc_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
 
-    switch (value) {
-    case UR_USM_ALLOC_INFO_TYPE: {
-        const ur_usm_type_t *tptr = (const ur_usm_type_t *)ptr;
-        if (sizeof(ur_usm_type_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_usm_type_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
+    template<> inline ur_result_t printFlag<ur_device_init_flag_t>(std::ostream &os, uint32_t flag);
 
-        os << ")";
-    } break;
-    case UR_USM_ALLOC_INFO_BASE_PTR: {
-        const void *const *tptr = (const void *const *)ptr;
-        if (sizeof(void *) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(void *) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_USM_ALLOC_INFO_SIZE: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_USM_ALLOC_INFO_DEVICE: {
-        const ur_device_handle_t *tptr = (const ur_device_handle_t *)ptr;
-        if (sizeof(ur_device_handle_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_handle_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        ur::details::printPtr(os,
-                              *tptr);
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_loader_config_info_t value, size_t size);
 
-        os << ")";
-    } break;
-    case UR_USM_ALLOC_INFO_POOL: {
-        const ur_usm_pool_handle_t *tptr = (const ur_usm_pool_handle_t *)ptr;
-        if (sizeof(ur_usm_pool_handle_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_usm_pool_handle_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        ur::details::printPtr(os,
-                              *tptr);
 
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_advice_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_usm_advice_flag_t value) {
-    switch (value) {
-    case UR_USM_ADVICE_FLAG_DEFAULT:
-        os << "UR_USM_ADVICE_FLAG_DEFAULT";
-        break;
-    case UR_USM_ADVICE_FLAG_SET_READ_MOSTLY:
-        os << "UR_USM_ADVICE_FLAG_SET_READ_MOSTLY";
-        break;
-    case UR_USM_ADVICE_FLAG_CLEAR_READ_MOSTLY:
-        os << "UR_USM_ADVICE_FLAG_CLEAR_READ_MOSTLY";
-        break;
-    case UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION:
-        os << "UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION";
-        break;
-    case UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION:
-        os << "UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION";
-        break;
-    case UR_USM_ADVICE_FLAG_SET_NON_ATOMIC_MOSTLY:
-        os << "UR_USM_ADVICE_FLAG_SET_NON_ATOMIC_MOSTLY";
-        break;
-    case UR_USM_ADVICE_FLAG_CLEAR_NON_ATOMIC_MOSTLY:
-        os << "UR_USM_ADVICE_FLAG_CLEAR_NON_ATOMIC_MOSTLY";
-        break;
-    case UR_USM_ADVICE_FLAG_BIAS_CACHED:
-        os << "UR_USM_ADVICE_FLAG_BIAS_CACHED";
-        break;
-    case UR_USM_ADVICE_FLAG_BIAS_UNCACHED:
-        os << "UR_USM_ADVICE_FLAG_BIAS_UNCACHED";
-        break;
-    case UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_DEVICE:
-        os << "UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_DEVICE";
-        break;
-    case UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_DEVICE:
-        os << "UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_DEVICE";
-        break;
-    case UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_HOST:
-        os << "UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_HOST";
-        break;
-    case UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_HOST:
-        os << "UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_HOST";
-        break;
-    case UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION_HOST:
-        os << "UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION_HOST";
-        break;
-    case UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION_HOST:
-        os << "UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION_HOST";
-        break;
-    case UR_USM_ADVICE_FLAG_SET_NON_COHERENT_MEMORY:
-        os << "UR_USM_ADVICE_FLAG_SET_NON_COHERENT_MEMORY";
-        break;
-    case UR_USM_ADVICE_FLAG_CLEAR_NON_COHERENT_MEMORY:
-        os << "UR_USM_ADVICE_FLAG_CLEAR_NON_COHERENT_MEMORY";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
 
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_usm_advice_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_usm_advice_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_USM_ADVICE_FLAG_DEFAULT) == (uint32_t)UR_USM_ADVICE_FLAG_DEFAULT) {
-        val ^= (uint32_t)UR_USM_ADVICE_FLAG_DEFAULT;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_ADVICE_FLAG_DEFAULT;
-    }
 
-    if ((val & UR_USM_ADVICE_FLAG_SET_READ_MOSTLY) == (uint32_t)UR_USM_ADVICE_FLAG_SET_READ_MOSTLY) {
-        val ^= (uint32_t)UR_USM_ADVICE_FLAG_SET_READ_MOSTLY;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_ADVICE_FLAG_SET_READ_MOSTLY;
-    }
 
-    if ((val & UR_USM_ADVICE_FLAG_CLEAR_READ_MOSTLY) == (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_READ_MOSTLY) {
-        val ^= (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_READ_MOSTLY;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_ADVICE_FLAG_CLEAR_READ_MOSTLY;
-    }
 
-    if ((val & UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION) == (uint32_t)UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION) {
-        val ^= (uint32_t)UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION;
-    }
 
-    if ((val & UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION) == (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION) {
-        val ^= (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION;
-    }
 
-    if ((val & UR_USM_ADVICE_FLAG_SET_NON_ATOMIC_MOSTLY) == (uint32_t)UR_USM_ADVICE_FLAG_SET_NON_ATOMIC_MOSTLY) {
-        val ^= (uint32_t)UR_USM_ADVICE_FLAG_SET_NON_ATOMIC_MOSTLY;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_ADVICE_FLAG_SET_NON_ATOMIC_MOSTLY;
-    }
 
-    if ((val & UR_USM_ADVICE_FLAG_CLEAR_NON_ATOMIC_MOSTLY) == (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_NON_ATOMIC_MOSTLY) {
-        val ^= (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_NON_ATOMIC_MOSTLY;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_ADVICE_FLAG_CLEAR_NON_ATOMIC_MOSTLY;
-    }
 
-    if ((val & UR_USM_ADVICE_FLAG_BIAS_CACHED) == (uint32_t)UR_USM_ADVICE_FLAG_BIAS_CACHED) {
-        val ^= (uint32_t)UR_USM_ADVICE_FLAG_BIAS_CACHED;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_ADVICE_FLAG_BIAS_CACHED;
-    }
 
-    if ((val & UR_USM_ADVICE_FLAG_BIAS_UNCACHED) == (uint32_t)UR_USM_ADVICE_FLAG_BIAS_UNCACHED) {
-        val ^= (uint32_t)UR_USM_ADVICE_FLAG_BIAS_UNCACHED;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_ADVICE_FLAG_BIAS_UNCACHED;
-    }
 
-    if ((val & UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_DEVICE) == (uint32_t)UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_DEVICE) {
-        val ^= (uint32_t)UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_DEVICE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_DEVICE;
-    }
 
-    if ((val & UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_DEVICE) == (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_DEVICE) {
-        val ^= (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_DEVICE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_DEVICE;
-    }
 
-    if ((val & UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_HOST) == (uint32_t)UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_HOST) {
-        val ^= (uint32_t)UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_HOST;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_HOST;
-    }
 
-    if ((val & UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_HOST) == (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_HOST) {
-        val ^= (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_HOST;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_HOST;
-    }
 
-    if ((val & UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION_HOST) == (uint32_t)UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION_HOST) {
-        val ^= (uint32_t)UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION_HOST;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION_HOST;
-    }
 
-    if ((val & UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION_HOST) == (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION_HOST) {
-        val ^= (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION_HOST;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION_HOST;
-    }
 
-    if ((val & UR_USM_ADVICE_FLAG_SET_NON_COHERENT_MEMORY) == (uint32_t)UR_USM_ADVICE_FLAG_SET_NON_COHERENT_MEMORY) {
-        val ^= (uint32_t)UR_USM_ADVICE_FLAG_SET_NON_COHERENT_MEMORY;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_ADVICE_FLAG_SET_NON_COHERENT_MEMORY;
-    }
 
-    if ((val & UR_USM_ADVICE_FLAG_CLEAR_NON_COHERENT_MEMORY) == (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_NON_COHERENT_MEMORY) {
-        val ^= (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_NON_COHERENT_MEMORY;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_ADVICE_FLAG_CLEAR_NON_COHERENT_MEMORY;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_desc_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_usm_desc_t params) {
-    os << "(struct ur_usm_desc_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".hints = ";
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_adapter_info_t value, size_t size);
 
-    ur::details::printFlag<ur_usm_advice_flag_t>(os,
-                                                 (params.hints));
 
-    os << ", ";
-    os << ".align = ";
 
-    os << (params.align);
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_host_desc_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_usm_host_desc_t params) {
-    os << "(struct ur_usm_host_desc_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_platform_info_t value, size_t size);
+
+
+
+
 
-    os << ", ";
-    os << ".flags = ";
 
-    ur::details::printFlag<ur_usm_host_mem_flag_t>(os,
-                                                   (params.flags));
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_device_desc_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_usm_device_desc_t params) {
-    os << "(struct ur_usm_device_desc_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".flags = ";
 
-    ur::details::printFlag<ur_usm_device_mem_flag_t>(os,
-                                                     (params.flags));
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_alloc_location_desc_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_usm_alloc_location_desc_t params) {
-    os << "(struct ur_usm_alloc_location_desc_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".location = ";
 
-    os << (params.location);
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_pool_desc_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_usm_pool_desc_t params) {
-    os << "(struct ur_usm_pool_desc_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".flags = ";
 
-    ur::details::printFlag<ur_usm_pool_flag_t>(os,
-                                               (params.flags));
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_pool_limits_desc_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_usm_pool_limits_desc_t params) {
-    os << "(struct ur_usm_pool_limits_desc_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".maxPoolableSize = ";
 
-    os << (params.maxPoolableSize);
 
-    os << ", ";
-    os << ".minDriverAllocSize = ";
 
-    os << (params.minDriverAllocSize);
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_pool_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_usm_pool_info_t value) {
-    switch (value) {
-    case UR_USM_POOL_INFO_REFERENCE_COUNT:
-        os << "UR_USM_POOL_INFO_REFERENCE_COUNT";
-        break;
-    case UR_USM_POOL_INFO_CONTEXT:
-        os << "UR_USM_POOL_INFO_CONTEXT";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_usm_pool_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_usm_pool_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
 
-    switch (value) {
-    case UR_USM_POOL_INFO_REFERENCE_COUNT: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_USM_POOL_INFO_CONTEXT: {
-        const ur_context_handle_t *tptr = (const ur_context_handle_t *)ptr;
-        if (sizeof(ur_context_handle_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_context_handle_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        ur::details::printPtr(os,
-                              *tptr);
 
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_virtual_mem_granularity_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_virtual_mem_granularity_info_t value) {
-    switch (value) {
-    case UR_VIRTUAL_MEM_GRANULARITY_INFO_MINIMUM:
-        os << "UR_VIRTUAL_MEM_GRANULARITY_INFO_MINIMUM";
-        break;
-    case UR_VIRTUAL_MEM_GRANULARITY_INFO_RECOMMENDED:
-        os << "UR_VIRTUAL_MEM_GRANULARITY_INFO_RECOMMENDED";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_virtual_mem_granularity_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_virtual_mem_granularity_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
 
-    switch (value) {
-    case UR_VIRTUAL_MEM_GRANULARITY_INFO_MINIMUM: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_device_info_t value, size_t size);
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_VIRTUAL_MEM_GRANULARITY_INFO_RECOMMENDED: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_virtual_mem_access_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_virtual_mem_access_flag_t value) {
-    switch (value) {
-    case UR_VIRTUAL_MEM_ACCESS_FLAG_NONE:
-        os << "UR_VIRTUAL_MEM_ACCESS_FLAG_NONE";
-        break;
-    case UR_VIRTUAL_MEM_ACCESS_FLAG_READ_WRITE:
-        os << "UR_VIRTUAL_MEM_ACCESS_FLAG_READ_WRITE";
-        break;
-    case UR_VIRTUAL_MEM_ACCESS_FLAG_READ_ONLY:
-        os << "UR_VIRTUAL_MEM_ACCESS_FLAG_READ_ONLY";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
 
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_virtual_mem_access_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_virtual_mem_access_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_VIRTUAL_MEM_ACCESS_FLAG_NONE) == (uint32_t)UR_VIRTUAL_MEM_ACCESS_FLAG_NONE) {
-        val ^= (uint32_t)UR_VIRTUAL_MEM_ACCESS_FLAG_NONE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_VIRTUAL_MEM_ACCESS_FLAG_NONE;
-    }
 
-    if ((val & UR_VIRTUAL_MEM_ACCESS_FLAG_READ_WRITE) == (uint32_t)UR_VIRTUAL_MEM_ACCESS_FLAG_READ_WRITE) {
-        val ^= (uint32_t)UR_VIRTUAL_MEM_ACCESS_FLAG_READ_WRITE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_VIRTUAL_MEM_ACCESS_FLAG_READ_WRITE;
-    }
 
-    if ((val & UR_VIRTUAL_MEM_ACCESS_FLAG_READ_ONLY) == (uint32_t)UR_VIRTUAL_MEM_ACCESS_FLAG_READ_ONLY) {
-        val ^= (uint32_t)UR_VIRTUAL_MEM_ACCESS_FLAG_READ_ONLY;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_VIRTUAL_MEM_ACCESS_FLAG_READ_ONLY;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_virtual_mem_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_virtual_mem_info_t value) {
-    switch (value) {
-    case UR_VIRTUAL_MEM_INFO_ACCESS_MODE:
-        os << "UR_VIRTUAL_MEM_INFO_ACCESS_MODE";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_virtual_mem_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_virtual_mem_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
 
-    switch (value) {
-    case UR_VIRTUAL_MEM_INFO_ACCESS_MODE: {
-        const ur_virtual_mem_access_flags_t *tptr = (const ur_virtual_mem_access_flags_t *)ptr;
-        if (sizeof(ur_virtual_mem_access_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_virtual_mem_access_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        ur::details::printFlag<ur_virtual_mem_access_flag_t>(os,
-                                                             *tptr);
+    template<> inline ur_result_t printFlag<ur_device_affinity_domain_flag_t>(std::ostream &os, uint32_t flag);
 
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_physical_mem_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_physical_mem_flag_t value) {
-    switch (value) {
-    case UR_PHYSICAL_MEM_FLAG_TBD:
-        os << "UR_PHYSICAL_MEM_FLAG_TBD";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
 
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_physical_mem_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_physical_mem_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_PHYSICAL_MEM_FLAG_TBD) == (uint32_t)UR_PHYSICAL_MEM_FLAG_TBD) {
-        val ^= (uint32_t)UR_PHYSICAL_MEM_FLAG_TBD;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_PHYSICAL_MEM_FLAG_TBD;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_physical_mem_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_physical_mem_properties_t params) {
-    os << "(struct ur_physical_mem_properties_t){";
+    
+    inline ur_result_t printUnion(
+        std::ostream &os,
+        const union ur_device_partition_value_t params,
+        const enum ur_device_partition_t tag
+    );
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".flags = ";
 
-    ur::details::printFlag<ur_physical_mem_flag_t>(os,
-                                                   (params.flags));
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_metadata_type_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_program_metadata_type_t value) {
-    switch (value) {
-    case UR_PROGRAM_METADATA_TYPE_UINT32:
-        os << "UR_PROGRAM_METADATA_TYPE_UINT32";
-        break;
-    case UR_PROGRAM_METADATA_TYPE_UINT64:
-        os << "UR_PROGRAM_METADATA_TYPE_UINT64";
-        break;
-    case UR_PROGRAM_METADATA_TYPE_BYTE_ARRAY:
-        os << "UR_PROGRAM_METADATA_TYPE_BYTE_ARRAY";
-        break;
-    case UR_PROGRAM_METADATA_TYPE_STRING:
-        os << "UR_PROGRAM_METADATA_TYPE_STRING";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
 
-///////////////////////////////////////////////////////////////////////////////
-// @brief Print ur_program_metadata_value_t union
-inline ur_result_t printUnion(
-    std::ostream &os,
-    const union ur_program_metadata_value_t params,
-    const enum ur_program_metadata_type_t tag) {
-    os << "(union ur_program_metadata_value_t){";
 
-    switch (tag) {
-    case UR_PROGRAM_METADATA_TYPE_UINT32:
 
-        os << ".data32 = ";
 
-        os << (params.data32);
+    template<> inline ur_result_t printFlag<ur_device_fp_capability_flag_t>(std::ostream &os, uint32_t flag);
 
-        break;
-    case UR_PROGRAM_METADATA_TYPE_UINT64:
 
-        os << ".data64 = ";
 
-        os << (params.data64);
 
-        break;
-    case UR_PROGRAM_METADATA_TYPE_STRING:
 
-        os << ".pString = ";
 
-        ur::details::printPtr(os,
-                              (params.pString));
+    template<> inline ur_result_t printFlag<ur_device_exec_capability_flag_t>(std::ostream &os, uint32_t flag);
 
-        break;
-    case UR_PROGRAM_METADATA_TYPE_BYTE_ARRAY:
 
-        os << ".pData = ";
 
-        ur::details::printPtr(os,
-                              (params.pData));
 
-        break;
-    default:
-        os << "<unknown>";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    os << "}";
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_metadata_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_program_metadata_t params) {
-    os << "(struct ur_program_metadata_t){";
 
-    os << ".pName = ";
 
-    ur::details::printPtr(os,
-                          (params.pName));
 
-    os << ", ";
-    os << ".type = ";
 
-    os << (params.type);
 
-    os << ", ";
-    os << ".size = ";
 
-    os << (params.size);
 
-    os << ", ";
-    os << ".value = ";
-    ur::details::printUnion(os, (params.value), params.type);
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_program_properties_t params) {
-    os << "(struct ur_program_properties_t){";
+    template<> inline ur_result_t printFlag<ur_memory_order_capability_flag_t>(std::ostream &os, uint32_t flag);
 
-    os << ".stype = ";
 
-    os << (params.stype);
+    template<> inline ur_result_t printFlag<ur_memory_scope_capability_flag_t>(std::ostream &os, uint32_t flag);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
+    template<> inline ur_result_t printFlag<ur_device_usm_access_capability_flag_t>(std::ostream &os, uint32_t flag);
 
-    os << ", ";
-    os << ".count = ";
 
-    os << (params.count);
+    template<> inline ur_result_t printFlag<ur_context_flag_t>(std::ostream &os, uint32_t flag);
 
-    os << ", ";
-    os << ".pMetadatas = {";
-    for (size_t i = 0; (params.pMetadatas) != NULL && i < params.count; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        os << ((params.pMetadatas))[i];
-    }
-    os << "}";
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_program_info_t value) {
-    switch (value) {
-    case UR_PROGRAM_INFO_REFERENCE_COUNT:
-        os << "UR_PROGRAM_INFO_REFERENCE_COUNT";
-        break;
-    case UR_PROGRAM_INFO_CONTEXT:
-        os << "UR_PROGRAM_INFO_CONTEXT";
-        break;
-    case UR_PROGRAM_INFO_NUM_DEVICES:
-        os << "UR_PROGRAM_INFO_NUM_DEVICES";
-        break;
-    case UR_PROGRAM_INFO_DEVICES:
-        os << "UR_PROGRAM_INFO_DEVICES";
-        break;
-    case UR_PROGRAM_INFO_IL:
-        os << "UR_PROGRAM_INFO_IL";
-        break;
-    case UR_PROGRAM_INFO_BINARY_SIZES:
-        os << "UR_PROGRAM_INFO_BINARY_SIZES";
-        break;
-    case UR_PROGRAM_INFO_BINARIES:
-        os << "UR_PROGRAM_INFO_BINARIES";
-        break;
-    case UR_PROGRAM_INFO_NUM_KERNELS:
-        os << "UR_PROGRAM_INFO_NUM_KERNELS";
-        break;
-    case UR_PROGRAM_INFO_KERNEL_NAMES:
-        os << "UR_PROGRAM_INFO_KERNEL_NAMES";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_program_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_program_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
 
-    switch (value) {
-    case UR_PROGRAM_INFO_REFERENCE_COUNT: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_PROGRAM_INFO_CONTEXT: {
-        const ur_context_handle_t *tptr = (const ur_context_handle_t *)ptr;
-        if (sizeof(ur_context_handle_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_context_handle_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_context_info_t value, size_t size);
 
-        ur::details::printPtr(os,
-                              *tptr);
 
-        os << ")";
-    } break;
-    case UR_PROGRAM_INFO_NUM_DEVICES: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_PROGRAM_INFO_DEVICES: {
 
-        const ur_device_handle_t *tptr = (const ur_device_handle_t *)ptr;
-        os << "{";
-        size_t nelems = size / sizeof(ur_device_handle_t);
-        for (size_t i = 0; i < nelems; ++i) {
-            if (i != 0) {
-                os << ", ";
-            }
 
-            ur::details::printPtr(os,
-                                  tptr[i]);
-        }
-        os << "}";
-    } break;
-    case UR_PROGRAM_INFO_IL: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_PROGRAM_INFO_BINARY_SIZES: {
-
-        const size_t *tptr = (const size_t *)ptr;
-        os << "{";
-        size_t nelems = size / sizeof(size_t);
-        for (size_t i = 0; i < nelems; ++i) {
-            if (i != 0) {
-                os << ", ";
-            }
 
-            os << tptr[i];
-        }
-        os << "}";
-    } break;
-    case UR_PROGRAM_INFO_BINARIES: {
-
-        const unsigned char *tptr = (const unsigned char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_PROGRAM_INFO_NUM_KERNELS: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_PROGRAM_INFO_KERNEL_NAMES: {
 
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_build_status_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_program_build_status_t value) {
-    switch (value) {
-    case UR_PROGRAM_BUILD_STATUS_NONE:
-        os << "UR_PROGRAM_BUILD_STATUS_NONE";
-        break;
-    case UR_PROGRAM_BUILD_STATUS_ERROR:
-        os << "UR_PROGRAM_BUILD_STATUS_ERROR";
-        break;
-    case UR_PROGRAM_BUILD_STATUS_SUCCESS:
-        os << "UR_PROGRAM_BUILD_STATUS_SUCCESS";
-        break;
-    case UR_PROGRAM_BUILD_STATUS_IN_PROGRESS:
-        os << "UR_PROGRAM_BUILD_STATUS_IN_PROGRESS";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_binary_type_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_program_binary_type_t value) {
-    switch (value) {
-    case UR_PROGRAM_BINARY_TYPE_NONE:
-        os << "UR_PROGRAM_BINARY_TYPE_NONE";
-        break;
-    case UR_PROGRAM_BINARY_TYPE_COMPILED_OBJECT:
-        os << "UR_PROGRAM_BINARY_TYPE_COMPILED_OBJECT";
-        break;
-    case UR_PROGRAM_BINARY_TYPE_LIBRARY:
-        os << "UR_PROGRAM_BINARY_TYPE_LIBRARY";
-        break;
-    case UR_PROGRAM_BINARY_TYPE_EXECUTABLE:
-        os << "UR_PROGRAM_BINARY_TYPE_EXECUTABLE";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_build_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_program_build_info_t value) {
-    switch (value) {
-    case UR_PROGRAM_BUILD_INFO_STATUS:
-        os << "UR_PROGRAM_BUILD_INFO_STATUS";
-        break;
-    case UR_PROGRAM_BUILD_INFO_OPTIONS:
-        os << "UR_PROGRAM_BUILD_INFO_OPTIONS";
-        break;
-    case UR_PROGRAM_BUILD_INFO_LOG:
-        os << "UR_PROGRAM_BUILD_INFO_LOG";
-        break;
-    case UR_PROGRAM_BUILD_INFO_BINARY_TYPE:
-        os << "UR_PROGRAM_BUILD_INFO_BINARY_TYPE";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_program_build_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_program_build_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
 
-    switch (value) {
-    case UR_PROGRAM_BUILD_INFO_STATUS: {
-        const ur_program_build_status_t *tptr = (const ur_program_build_status_t *)ptr;
-        if (sizeof(ur_program_build_status_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_program_build_status_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_PROGRAM_BUILD_INFO_OPTIONS: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_PROGRAM_BUILD_INFO_LOG: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_PROGRAM_BUILD_INFO_BINARY_TYPE: {
-        const ur_program_binary_type_t *tptr = (const ur_program_binary_type_t *)ptr;
-        if (sizeof(ur_program_binary_type_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_program_binary_type_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_specialization_constant_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_specialization_constant_info_t params) {
-    os << "(struct ur_specialization_constant_info_t){";
 
-    os << ".id = ";
+    template<> inline ur_result_t printFlag<ur_mem_flag_t>(std::ostream &os, uint32_t flag);
 
-    os << (params.id);
 
-    os << ", ";
-    os << ".size = ";
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_mem_info_t value, size_t size);
 
-    os << (params.size);
 
-    os << ", ";
-    os << ".pValue = ";
 
-    ur::details::printPtr(os,
-                          (params.pValue));
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_native_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_program_native_properties_t params) {
-    os << "(struct ur_program_native_properties_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_image_info_t value, size_t size);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".isNativeHandleOwned = ";
 
-    os << (params.isNativeHandleOwned);
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_arg_value_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_kernel_arg_value_properties_t params) {
-    os << "(struct ur_kernel_arg_value_properties_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_arg_local_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_kernel_arg_local_properties_t params) {
-    os << "(struct ur_kernel_arg_local_properties_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_kernel_info_t value) {
-    switch (value) {
-    case UR_KERNEL_INFO_FUNCTION_NAME:
-        os << "UR_KERNEL_INFO_FUNCTION_NAME";
-        break;
-    case UR_KERNEL_INFO_NUM_ARGS:
-        os << "UR_KERNEL_INFO_NUM_ARGS";
-        break;
-    case UR_KERNEL_INFO_REFERENCE_COUNT:
-        os << "UR_KERNEL_INFO_REFERENCE_COUNT";
-        break;
-    case UR_KERNEL_INFO_CONTEXT:
-        os << "UR_KERNEL_INFO_CONTEXT";
-        break;
-    case UR_KERNEL_INFO_PROGRAM:
-        os << "UR_KERNEL_INFO_PROGRAM";
-        break;
-    case UR_KERNEL_INFO_ATTRIBUTES:
-        os << "UR_KERNEL_INFO_ATTRIBUTES";
-        break;
-    case UR_KERNEL_INFO_NUM_REGS:
-        os << "UR_KERNEL_INFO_NUM_REGS";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_kernel_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_kernel_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
 
-    switch (value) {
-    case UR_KERNEL_INFO_FUNCTION_NAME: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_KERNEL_INFO_NUM_ARGS: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_KERNEL_INFO_REFERENCE_COUNT: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_KERNEL_INFO_CONTEXT: {
-        const ur_context_handle_t *tptr = (const ur_context_handle_t *)ptr;
-        if (sizeof(ur_context_handle_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_context_handle_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        ur::details::printPtr(os,
-                              *tptr);
 
-        os << ")";
-    } break;
-    case UR_KERNEL_INFO_PROGRAM: {
-        const ur_program_handle_t *tptr = (const ur_program_handle_t *)ptr;
-        if (sizeof(ur_program_handle_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_program_handle_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        ur::details::printPtr(os,
-                              *tptr);
 
-        os << ")";
-    } break;
-    case UR_KERNEL_INFO_ATTRIBUTES: {
-
-        const char *tptr = (const char *)ptr;
-        printPtr(os, tptr);
-    } break;
-    case UR_KERNEL_INFO_NUM_REGS: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_group_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_kernel_group_info_t value) {
-    switch (value) {
-    case UR_KERNEL_GROUP_INFO_GLOBAL_WORK_SIZE:
-        os << "UR_KERNEL_GROUP_INFO_GLOBAL_WORK_SIZE";
-        break;
-    case UR_KERNEL_GROUP_INFO_WORK_GROUP_SIZE:
-        os << "UR_KERNEL_GROUP_INFO_WORK_GROUP_SIZE";
-        break;
-    case UR_KERNEL_GROUP_INFO_COMPILE_WORK_GROUP_SIZE:
-        os << "UR_KERNEL_GROUP_INFO_COMPILE_WORK_GROUP_SIZE";
-        break;
-    case UR_KERNEL_GROUP_INFO_LOCAL_MEM_SIZE:
-        os << "UR_KERNEL_GROUP_INFO_LOCAL_MEM_SIZE";
-        break;
-    case UR_KERNEL_GROUP_INFO_PREFERRED_WORK_GROUP_SIZE_MULTIPLE:
-        os << "UR_KERNEL_GROUP_INFO_PREFERRED_WORK_GROUP_SIZE_MULTIPLE";
-        break;
-    case UR_KERNEL_GROUP_INFO_PRIVATE_MEM_SIZE:
-        os << "UR_KERNEL_GROUP_INFO_PRIVATE_MEM_SIZE";
-        break;
-    case UR_KERNEL_GROUP_INFO_COMPILE_MAX_WORK_GROUP_SIZE:
-        os << "UR_KERNEL_GROUP_INFO_COMPILE_MAX_WORK_GROUP_SIZE";
-        break;
-    case UR_KERNEL_GROUP_INFO_COMPILE_MAX_LINEAR_WORK_GROUP_SIZE:
-        os << "UR_KERNEL_GROUP_INFO_COMPILE_MAX_LINEAR_WORK_GROUP_SIZE";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_kernel_group_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_kernel_group_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
 
-    switch (value) {
-    case UR_KERNEL_GROUP_INFO_GLOBAL_WORK_SIZE: {
 
-        const size_t *tptr = (const size_t *)ptr;
-        os << "{";
-        size_t nelems = size / sizeof(size_t);
-        for (size_t i = 0; i < nelems; ++i) {
-            if (i != 0) {
-                os << ", ";
-            }
 
-            os << tptr[i];
-        }
-        os << "}";
-    } break;
-    case UR_KERNEL_GROUP_INFO_WORK_GROUP_SIZE: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_KERNEL_GROUP_INFO_COMPILE_WORK_GROUP_SIZE: {
 
-        const size_t *tptr = (const size_t *)ptr;
-        os << "{";
-        size_t nelems = size / sizeof(size_t);
-        for (size_t i = 0; i < nelems; ++i) {
-            if (i != 0) {
-                os << ", ";
-            }
 
-            os << tptr[i];
-        }
-        os << "}";
-    } break;
-    case UR_KERNEL_GROUP_INFO_LOCAL_MEM_SIZE: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_KERNEL_GROUP_INFO_PREFERRED_WORK_GROUP_SIZE_MULTIPLE: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_KERNEL_GROUP_INFO_PRIVATE_MEM_SIZE: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_KERNEL_GROUP_INFO_COMPILE_MAX_WORK_GROUP_SIZE: {
 
-        const size_t *tptr = (const size_t *)ptr;
-        os << "{";
-        size_t nelems = size / sizeof(size_t);
-        for (size_t i = 0; i < nelems; ++i) {
-            if (i != 0) {
-                os << ", ";
-            }
 
-            os << tptr[i];
-        }
-        os << "}";
-    } break;
-    case UR_KERNEL_GROUP_INFO_COMPILE_MAX_LINEAR_WORK_GROUP_SIZE: {
-        const size_t *tptr = (const size_t *)ptr;
-        if (sizeof(size_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_sampler_info_t value, size_t size);
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_sub_group_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_kernel_sub_group_info_t value) {
-    switch (value) {
-    case UR_KERNEL_SUB_GROUP_INFO_MAX_SUB_GROUP_SIZE:
-        os << "UR_KERNEL_SUB_GROUP_INFO_MAX_SUB_GROUP_SIZE";
-        break;
-    case UR_KERNEL_SUB_GROUP_INFO_MAX_NUM_SUB_GROUPS:
-        os << "UR_KERNEL_SUB_GROUP_INFO_MAX_NUM_SUB_GROUPS";
-        break;
-    case UR_KERNEL_SUB_GROUP_INFO_COMPILE_NUM_SUB_GROUPS:
-        os << "UR_KERNEL_SUB_GROUP_INFO_COMPILE_NUM_SUB_GROUPS";
-        break;
-    case UR_KERNEL_SUB_GROUP_INFO_SUB_GROUP_SIZE_INTEL:
-        os << "UR_KERNEL_SUB_GROUP_INFO_SUB_GROUP_SIZE_INTEL";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_kernel_sub_group_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_kernel_sub_group_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
 
-    switch (value) {
-    case UR_KERNEL_SUB_GROUP_INFO_MAX_SUB_GROUP_SIZE: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_KERNEL_SUB_GROUP_INFO_MAX_NUM_SUB_GROUPS: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_KERNEL_SUB_GROUP_INFO_COMPILE_NUM_SUB_GROUPS: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_KERNEL_SUB_GROUP_INFO_SUB_GROUP_SIZE_INTEL: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_cache_config_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_kernel_cache_config_t value) {
-    switch (value) {
-    case UR_KERNEL_CACHE_CONFIG_DEFAULT:
-        os << "UR_KERNEL_CACHE_CONFIG_DEFAULT";
-        break;
-    case UR_KERNEL_CACHE_CONFIG_LARGE_SLM:
-        os << "UR_KERNEL_CACHE_CONFIG_LARGE_SLM";
-        break;
-    case UR_KERNEL_CACHE_CONFIG_LARGE_DATA:
-        os << "UR_KERNEL_CACHE_CONFIG_LARGE_DATA";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_exec_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_kernel_exec_info_t value) {
-    switch (value) {
-    case UR_KERNEL_EXEC_INFO_USM_INDIRECT_ACCESS:
-        os << "UR_KERNEL_EXEC_INFO_USM_INDIRECT_ACCESS";
-        break;
-    case UR_KERNEL_EXEC_INFO_USM_PTRS:
-        os << "UR_KERNEL_EXEC_INFO_USM_PTRS";
-        break;
-    case UR_KERNEL_EXEC_INFO_CACHE_CONFIG:
-        os << "UR_KERNEL_EXEC_INFO_CACHE_CONFIG";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_kernel_exec_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_kernel_exec_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
 
-    switch (value) {
-    case UR_KERNEL_EXEC_INFO_USM_INDIRECT_ACCESS: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_KERNEL_EXEC_INFO_USM_PTRS: {
 
-        const void *const *tptr = (const void *const *)ptr;
-        os << "{";
-        size_t nelems = size / sizeof(void *);
-        for (size_t i = 0; i < nelems; ++i) {
-            if (i != 0) {
-                os << ", ";
-            }
 
-            os << tptr[i];
-        }
-        os << "}";
-    } break;
-    case UR_KERNEL_EXEC_INFO_CACHE_CONFIG: {
-        const ur_kernel_cache_config_t *tptr = (const ur_kernel_cache_config_t *)ptr;
-        if (sizeof(ur_kernel_cache_config_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_kernel_cache_config_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
+    template<> inline ur_result_t printFlag<ur_usm_host_mem_flag_t>(std::ostream &os, uint32_t flag);
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_arg_pointer_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_kernel_arg_pointer_properties_t params) {
-    os << "(struct ur_kernel_arg_pointer_properties_t){";
 
-    os << ".stype = ";
+    template<> inline ur_result_t printFlag<ur_usm_device_mem_flag_t>(std::ostream &os, uint32_t flag);
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
+    template<> inline ur_result_t printFlag<ur_usm_pool_flag_t>(std::ostream &os, uint32_t flag);
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_exec_info_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_kernel_exec_info_properties_t params) {
-    os << "(struct ur_kernel_exec_info_properties_t){";
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_usm_alloc_info_t value, size_t size);
+
+
+
+
+    template<> inline ur_result_t printFlag<ur_usm_advice_flag_t>(std::ostream &os, uint32_t flag);
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_arg_sampler_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_kernel_arg_sampler_properties_t params) {
-    os << "(struct ur_kernel_arg_sampler_properties_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_arg_mem_obj_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_kernel_arg_mem_obj_properties_t params) {
-    os << "(struct ur_kernel_arg_mem_obj_properties_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".memoryAccess = ";
 
-    ur::details::printFlag<ur_mem_flag_t>(os,
-                                          (params.memoryAccess));
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_native_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_kernel_native_properties_t params) {
-    os << "(struct ur_kernel_native_properties_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".isNativeHandleOwned = ";
 
-    os << (params.isNativeHandleOwned);
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_queue_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_queue_info_t value) {
-    switch (value) {
-    case UR_QUEUE_INFO_CONTEXT:
-        os << "UR_QUEUE_INFO_CONTEXT";
-        break;
-    case UR_QUEUE_INFO_DEVICE:
-        os << "UR_QUEUE_INFO_DEVICE";
-        break;
-    case UR_QUEUE_INFO_DEVICE_DEFAULT:
-        os << "UR_QUEUE_INFO_DEVICE_DEFAULT";
-        break;
-    case UR_QUEUE_INFO_FLAGS:
-        os << "UR_QUEUE_INFO_FLAGS";
-        break;
-    case UR_QUEUE_INFO_REFERENCE_COUNT:
-        os << "UR_QUEUE_INFO_REFERENCE_COUNT";
-        break;
-    case UR_QUEUE_INFO_SIZE:
-        os << "UR_QUEUE_INFO_SIZE";
-        break;
-    case UR_QUEUE_INFO_EMPTY:
-        os << "UR_QUEUE_INFO_EMPTY";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_queue_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_queue_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
 
-    switch (value) {
-    case UR_QUEUE_INFO_CONTEXT: {
-        const ur_context_handle_t *tptr = (const ur_context_handle_t *)ptr;
-        if (sizeof(ur_context_handle_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_context_handle_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        ur::details::printPtr(os,
-                              *tptr);
 
-        os << ")";
-    } break;
-    case UR_QUEUE_INFO_DEVICE: {
-        const ur_device_handle_t *tptr = (const ur_device_handle_t *)ptr;
-        if (sizeof(ur_device_handle_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_handle_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        ur::details::printPtr(os,
-                              *tptr);
 
-        os << ")";
-    } break;
-    case UR_QUEUE_INFO_DEVICE_DEFAULT: {
-        const ur_queue_handle_t *tptr = (const ur_queue_handle_t *)ptr;
-        if (sizeof(ur_queue_handle_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_queue_handle_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        ur::details::printPtr(os,
-                              *tptr);
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_usm_pool_info_t value, size_t size);
 
-        os << ")";
-    } break;
-    case UR_QUEUE_INFO_FLAGS: {
-        const ur_queue_flags_t *tptr = (const ur_queue_flags_t *)ptr;
-        if (sizeof(ur_queue_flags_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_queue_flags_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        ur::details::printFlag<ur_queue_flag_t>(os,
-                                                *tptr);
 
-        os << ")";
-    } break;
-    case UR_QUEUE_INFO_REFERENCE_COUNT: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_virtual_mem_granularity_info_t value, size_t size);
 
-        os << ")";
-    } break;
-    case UR_QUEUE_INFO_SIZE: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_QUEUE_INFO_EMPTY: {
-        const ur_bool_t *tptr = (const ur_bool_t *)ptr;
-        if (sizeof(ur_bool_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_queue_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_queue_flag_t value) {
-    switch (value) {
-    case UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE:
-        os << "UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE";
-        break;
-    case UR_QUEUE_FLAG_PROFILING_ENABLE:
-        os << "UR_QUEUE_FLAG_PROFILING_ENABLE";
-        break;
-    case UR_QUEUE_FLAG_ON_DEVICE:
-        os << "UR_QUEUE_FLAG_ON_DEVICE";
-        break;
-    case UR_QUEUE_FLAG_ON_DEVICE_DEFAULT:
-        os << "UR_QUEUE_FLAG_ON_DEVICE_DEFAULT";
-        break;
-    case UR_QUEUE_FLAG_DISCARD_EVENTS:
-        os << "UR_QUEUE_FLAG_DISCARD_EVENTS";
-        break;
-    case UR_QUEUE_FLAG_PRIORITY_LOW:
-        os << "UR_QUEUE_FLAG_PRIORITY_LOW";
-        break;
-    case UR_QUEUE_FLAG_PRIORITY_HIGH:
-        os << "UR_QUEUE_FLAG_PRIORITY_HIGH";
-        break;
-    case UR_QUEUE_FLAG_SUBMISSION_BATCHED:
-        os << "UR_QUEUE_FLAG_SUBMISSION_BATCHED";
-        break;
-    case UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE:
-        os << "UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE";
-        break;
-    case UR_QUEUE_FLAG_USE_DEFAULT_STREAM:
-        os << "UR_QUEUE_FLAG_USE_DEFAULT_STREAM";
-        break;
-    case UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM:
-        os << "UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
 
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_queue_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_queue_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE) == (uint32_t)UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE) {
-        val ^= (uint32_t)UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE;
-    }
 
-    if ((val & UR_QUEUE_FLAG_PROFILING_ENABLE) == (uint32_t)UR_QUEUE_FLAG_PROFILING_ENABLE) {
-        val ^= (uint32_t)UR_QUEUE_FLAG_PROFILING_ENABLE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_QUEUE_FLAG_PROFILING_ENABLE;
-    }
 
-    if ((val & UR_QUEUE_FLAG_ON_DEVICE) == (uint32_t)UR_QUEUE_FLAG_ON_DEVICE) {
-        val ^= (uint32_t)UR_QUEUE_FLAG_ON_DEVICE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_QUEUE_FLAG_ON_DEVICE;
-    }
 
-    if ((val & UR_QUEUE_FLAG_ON_DEVICE_DEFAULT) == (uint32_t)UR_QUEUE_FLAG_ON_DEVICE_DEFAULT) {
-        val ^= (uint32_t)UR_QUEUE_FLAG_ON_DEVICE_DEFAULT;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_QUEUE_FLAG_ON_DEVICE_DEFAULT;
-    }
+    template<> inline ur_result_t printFlag<ur_virtual_mem_access_flag_t>(std::ostream &os, uint32_t flag);
 
-    if ((val & UR_QUEUE_FLAG_DISCARD_EVENTS) == (uint32_t)UR_QUEUE_FLAG_DISCARD_EVENTS) {
-        val ^= (uint32_t)UR_QUEUE_FLAG_DISCARD_EVENTS;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_QUEUE_FLAG_DISCARD_EVENTS;
-    }
 
-    if ((val & UR_QUEUE_FLAG_PRIORITY_LOW) == (uint32_t)UR_QUEUE_FLAG_PRIORITY_LOW) {
-        val ^= (uint32_t)UR_QUEUE_FLAG_PRIORITY_LOW;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_QUEUE_FLAG_PRIORITY_LOW;
-    }
 
-    if ((val & UR_QUEUE_FLAG_PRIORITY_HIGH) == (uint32_t)UR_QUEUE_FLAG_PRIORITY_HIGH) {
-        val ^= (uint32_t)UR_QUEUE_FLAG_PRIORITY_HIGH;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_QUEUE_FLAG_PRIORITY_HIGH;
-    }
 
-    if ((val & UR_QUEUE_FLAG_SUBMISSION_BATCHED) == (uint32_t)UR_QUEUE_FLAG_SUBMISSION_BATCHED) {
-        val ^= (uint32_t)UR_QUEUE_FLAG_SUBMISSION_BATCHED;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_QUEUE_FLAG_SUBMISSION_BATCHED;
-    }
 
-    if ((val & UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE) == (uint32_t)UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE) {
-        val ^= (uint32_t)UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE;
-    }
 
-    if ((val & UR_QUEUE_FLAG_USE_DEFAULT_STREAM) == (uint32_t)UR_QUEUE_FLAG_USE_DEFAULT_STREAM) {
-        val ^= (uint32_t)UR_QUEUE_FLAG_USE_DEFAULT_STREAM;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_QUEUE_FLAG_USE_DEFAULT_STREAM;
-    }
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_virtual_mem_info_t value, size_t size);
 
-    if ((val & UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM) == (uint32_t)UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM) {
-        val ^= (uint32_t)UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_queue_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_queue_properties_t params) {
-    os << "(struct ur_queue_properties_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".flags = ";
+    template<> inline ur_result_t printFlag<ur_physical_mem_flag_t>(std::ostream &os, uint32_t flag);
 
-    ur::details::printFlag<ur_queue_flag_t>(os,
-                                            (params.flags));
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_queue_index_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_queue_index_properties_t params) {
-    os << "(struct ur_queue_index_properties_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".computeIndex = ";
 
-    os << (params.computeIndex);
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_queue_native_desc_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_queue_native_desc_t params) {
-    os << "(struct ur_queue_native_desc_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
+    
+    inline ur_result_t printUnion(
+        std::ostream &os,
+        const union ur_program_metadata_value_t params,
+        const enum ur_program_metadata_type_t tag
+    );
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".pNativeData = ";
 
-    ur::details::printPtr(os,
-                          (params.pNativeData));
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_queue_native_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_queue_native_properties_t params) {
-    os << "(struct ur_queue_native_properties_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".isNativeHandleOwned = ";
 
-    os << (params.isNativeHandleOwned);
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_command_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_command_t value) {
-    switch (value) {
-    case UR_COMMAND_KERNEL_LAUNCH:
-        os << "UR_COMMAND_KERNEL_LAUNCH";
-        break;
-    case UR_COMMAND_EVENTS_WAIT:
-        os << "UR_COMMAND_EVENTS_WAIT";
-        break;
-    case UR_COMMAND_EVENTS_WAIT_WITH_BARRIER:
-        os << "UR_COMMAND_EVENTS_WAIT_WITH_BARRIER";
-        break;
-    case UR_COMMAND_MEM_BUFFER_READ:
-        os << "UR_COMMAND_MEM_BUFFER_READ";
-        break;
-    case UR_COMMAND_MEM_BUFFER_WRITE:
-        os << "UR_COMMAND_MEM_BUFFER_WRITE";
-        break;
-    case UR_COMMAND_MEM_BUFFER_READ_RECT:
-        os << "UR_COMMAND_MEM_BUFFER_READ_RECT";
-        break;
-    case UR_COMMAND_MEM_BUFFER_WRITE_RECT:
-        os << "UR_COMMAND_MEM_BUFFER_WRITE_RECT";
-        break;
-    case UR_COMMAND_MEM_BUFFER_COPY:
-        os << "UR_COMMAND_MEM_BUFFER_COPY";
-        break;
-    case UR_COMMAND_MEM_BUFFER_COPY_RECT:
-        os << "UR_COMMAND_MEM_BUFFER_COPY_RECT";
-        break;
-    case UR_COMMAND_MEM_BUFFER_FILL:
-        os << "UR_COMMAND_MEM_BUFFER_FILL";
-        break;
-    case UR_COMMAND_MEM_IMAGE_READ:
-        os << "UR_COMMAND_MEM_IMAGE_READ";
-        break;
-    case UR_COMMAND_MEM_IMAGE_WRITE:
-        os << "UR_COMMAND_MEM_IMAGE_WRITE";
-        break;
-    case UR_COMMAND_MEM_IMAGE_COPY:
-        os << "UR_COMMAND_MEM_IMAGE_COPY";
-        break;
-    case UR_COMMAND_MEM_BUFFER_MAP:
-        os << "UR_COMMAND_MEM_BUFFER_MAP";
-        break;
-    case UR_COMMAND_MEM_UNMAP:
-        os << "UR_COMMAND_MEM_UNMAP";
-        break;
-    case UR_COMMAND_USM_FILL:
-        os << "UR_COMMAND_USM_FILL";
-        break;
-    case UR_COMMAND_USM_MEMCPY:
-        os << "UR_COMMAND_USM_MEMCPY";
-        break;
-    case UR_COMMAND_USM_PREFETCH:
-        os << "UR_COMMAND_USM_PREFETCH";
-        break;
-    case UR_COMMAND_USM_ADVISE:
-        os << "UR_COMMAND_USM_ADVISE";
-        break;
-    case UR_COMMAND_USM_FILL_2D:
-        os << "UR_COMMAND_USM_FILL_2D";
-        break;
-    case UR_COMMAND_USM_MEMCPY_2D:
-        os << "UR_COMMAND_USM_MEMCPY_2D";
-        break;
-    case UR_COMMAND_DEVICE_GLOBAL_VARIABLE_WRITE:
-        os << "UR_COMMAND_DEVICE_GLOBAL_VARIABLE_WRITE";
-        break;
-    case UR_COMMAND_DEVICE_GLOBAL_VARIABLE_READ:
-        os << "UR_COMMAND_DEVICE_GLOBAL_VARIABLE_READ";
-        break;
-    case UR_COMMAND_READ_HOST_PIPE:
-        os << "UR_COMMAND_READ_HOST_PIPE";
-        break;
-    case UR_COMMAND_WRITE_HOST_PIPE:
-        os << "UR_COMMAND_WRITE_HOST_PIPE";
-        break;
-    case UR_COMMAND_COMMAND_BUFFER_ENQUEUE_EXP:
-        os << "UR_COMMAND_COMMAND_BUFFER_ENQUEUE_EXP";
-        break;
-    case UR_COMMAND_EXTERNAL_SEMAPHORE_WAIT_EXP:
-        os << "UR_COMMAND_EXTERNAL_SEMAPHORE_WAIT_EXP";
-        break;
-    case UR_COMMAND_EXTERNAL_SEMAPHORE_SIGNAL_EXP:
-        os << "UR_COMMAND_EXTERNAL_SEMAPHORE_SIGNAL_EXP";
-        break;
-    case UR_COMMAND_TIMESTAMP_RECORDING_EXP:
-        os << "UR_COMMAND_TIMESTAMP_RECORDING_EXP";
-        break;
-    case UR_COMMAND_ENQUEUE_NATIVE_EXP:
-        os << "UR_COMMAND_ENQUEUE_NATIVE_EXP";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_event_status_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_event_status_t value) {
-    switch (value) {
-    case UR_EVENT_STATUS_COMPLETE:
-        os << "UR_EVENT_STATUS_COMPLETE";
-        break;
-    case UR_EVENT_STATUS_RUNNING:
-        os << "UR_EVENT_STATUS_RUNNING";
-        break;
-    case UR_EVENT_STATUS_SUBMITTED:
-        os << "UR_EVENT_STATUS_SUBMITTED";
-        break;
-    case UR_EVENT_STATUS_QUEUED:
-        os << "UR_EVENT_STATUS_QUEUED";
-        break;
-    case UR_EVENT_STATUS_ERROR:
-        os << "UR_EVENT_STATUS_ERROR";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_event_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_event_info_t value) {
-    switch (value) {
-    case UR_EVENT_INFO_COMMAND_QUEUE:
-        os << "UR_EVENT_INFO_COMMAND_QUEUE";
-        break;
-    case UR_EVENT_INFO_CONTEXT:
-        os << "UR_EVENT_INFO_CONTEXT";
-        break;
-    case UR_EVENT_INFO_COMMAND_TYPE:
-        os << "UR_EVENT_INFO_COMMAND_TYPE";
-        break;
-    case UR_EVENT_INFO_COMMAND_EXECUTION_STATUS:
-        os << "UR_EVENT_INFO_COMMAND_EXECUTION_STATUS";
-        break;
-    case UR_EVENT_INFO_REFERENCE_COUNT:
-        os << "UR_EVENT_INFO_REFERENCE_COUNT";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_event_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_event_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
 
-    switch (value) {
-    case UR_EVENT_INFO_COMMAND_QUEUE: {
-        const ur_queue_handle_t *tptr = (const ur_queue_handle_t *)ptr;
-        if (sizeof(ur_queue_handle_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_queue_handle_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        ur::details::printPtr(os,
-                              *tptr);
 
-        os << ")";
-    } break;
-    case UR_EVENT_INFO_CONTEXT: {
-        const ur_context_handle_t *tptr = (const ur_context_handle_t *)ptr;
-        if (sizeof(ur_context_handle_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_context_handle_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        ur::details::printPtr(os,
-                              *tptr);
 
-        os << ")";
-    } break;
-    case UR_EVENT_INFO_COMMAND_TYPE: {
-        const ur_command_t *tptr = (const ur_command_t *)ptr;
-        if (sizeof(ur_command_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_command_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_EVENT_INFO_COMMAND_EXECUTION_STATUS: {
-        const ur_event_status_t *tptr = (const ur_event_status_t *)ptr;
-        if (sizeof(ur_event_status_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_event_status_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_EVENT_INFO_REFERENCE_COUNT: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_program_info_t value, size_t size);
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_profiling_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_profiling_info_t value) {
-    switch (value) {
-    case UR_PROFILING_INFO_COMMAND_QUEUED:
-        os << "UR_PROFILING_INFO_COMMAND_QUEUED";
-        break;
-    case UR_PROFILING_INFO_COMMAND_SUBMIT:
-        os << "UR_PROFILING_INFO_COMMAND_SUBMIT";
-        break;
-    case UR_PROFILING_INFO_COMMAND_START:
-        os << "UR_PROFILING_INFO_COMMAND_START";
-        break;
-    case UR_PROFILING_INFO_COMMAND_END:
-        os << "UR_PROFILING_INFO_COMMAND_END";
-        break;
-    case UR_PROFILING_INFO_COMMAND_COMPLETE:
-        os << "UR_PROFILING_INFO_COMMAND_COMPLETE";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_profiling_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_profiling_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
 
-    switch (value) {
-    case UR_PROFILING_INFO_COMMAND_QUEUED: {
-        const uint64_t *tptr = (const uint64_t *)ptr;
-        if (sizeof(uint64_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_PROFILING_INFO_COMMAND_SUBMIT: {
-        const uint64_t *tptr = (const uint64_t *)ptr;
-        if (sizeof(uint64_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_PROFILING_INFO_COMMAND_START: {
-        const uint64_t *tptr = (const uint64_t *)ptr;
-        if (sizeof(uint64_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_PROFILING_INFO_COMMAND_END: {
-        const uint64_t *tptr = (const uint64_t *)ptr;
-        if (sizeof(uint64_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_program_build_info_t value, size_t size);
+
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_PROFILING_INFO_COMMAND_COMPLETE: {
-        const uint64_t *tptr = (const uint64_t *)ptr;
-        if (sizeof(uint64_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_event_native_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_event_native_properties_t params) {
-    os << "(struct ur_event_native_properties_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".isNativeHandleOwned = ";
 
-    os << (params.isNativeHandleOwned);
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_execution_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_execution_info_t value) {
-    switch (value) {
-    case UR_EXECUTION_INFO_COMPLETE:
-        os << "UR_EXECUTION_INFO_COMPLETE";
-        break;
-    case UR_EXECUTION_INFO_RUNNING:
-        os << "UR_EXECUTION_INFO_RUNNING";
-        break;
-    case UR_EXECUTION_INFO_SUBMITTED:
-        os << "UR_EXECUTION_INFO_SUBMITTED";
-        break;
-    case UR_EXECUTION_INFO_QUEUED:
-        os << "UR_EXECUTION_INFO_QUEUED";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_map_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_map_flag_t value) {
-    switch (value) {
-    case UR_MAP_FLAG_READ:
-        os << "UR_MAP_FLAG_READ";
-        break;
-    case UR_MAP_FLAG_WRITE:
-        os << "UR_MAP_FLAG_WRITE";
-        break;
-    case UR_MAP_FLAG_WRITE_INVALIDATE_REGION:
-        os << "UR_MAP_FLAG_WRITE_INVALIDATE_REGION";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
 
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_map_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_map_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_MAP_FLAG_READ) == (uint32_t)UR_MAP_FLAG_READ) {
-        val ^= (uint32_t)UR_MAP_FLAG_READ;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_MAP_FLAG_READ;
-    }
 
-    if ((val & UR_MAP_FLAG_WRITE) == (uint32_t)UR_MAP_FLAG_WRITE) {
-        val ^= (uint32_t)UR_MAP_FLAG_WRITE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_MAP_FLAG_WRITE;
-    }
 
-    if ((val & UR_MAP_FLAG_WRITE_INVALIDATE_REGION) == (uint32_t)UR_MAP_FLAG_WRITE_INVALIDATE_REGION) {
-        val ^= (uint32_t)UR_MAP_FLAG_WRITE_INVALIDATE_REGION;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_MAP_FLAG_WRITE_INVALIDATE_REGION;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_migration_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_usm_migration_flag_t value) {
-    switch (value) {
-    case UR_USM_MIGRATION_FLAG_DEFAULT:
-        os << "UR_USM_MIGRATION_FLAG_DEFAULT";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
 
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_usm_migration_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_usm_migration_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_USM_MIGRATION_FLAG_DEFAULT) == (uint32_t)UR_USM_MIGRATION_FLAG_DEFAULT) {
-        val ^= (uint32_t)UR_USM_MIGRATION_FLAG_DEFAULT;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_USM_MIGRATION_FLAG_DEFAULT;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_image_copy_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_exp_image_copy_flag_t value) {
-    switch (value) {
-    case UR_EXP_IMAGE_COPY_FLAG_HOST_TO_DEVICE:
-        os << "UR_EXP_IMAGE_COPY_FLAG_HOST_TO_DEVICE";
-        break;
-    case UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_HOST:
-        os << "UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_HOST";
-        break;
-    case UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_DEVICE:
-        os << "UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_DEVICE";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
 
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_exp_image_copy_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_exp_image_copy_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_EXP_IMAGE_COPY_FLAG_HOST_TO_DEVICE) == (uint32_t)UR_EXP_IMAGE_COPY_FLAG_HOST_TO_DEVICE) {
-        val ^= (uint32_t)UR_EXP_IMAGE_COPY_FLAG_HOST_TO_DEVICE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_EXP_IMAGE_COPY_FLAG_HOST_TO_DEVICE;
-    }
 
-    if ((val & UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_HOST) == (uint32_t)UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_HOST) {
-        val ^= (uint32_t)UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_HOST;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_HOST;
-    }
 
-    if ((val & UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_DEVICE) == (uint32_t)UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_DEVICE) {
-        val ^= (uint32_t)UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_DEVICE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_DEVICE;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_sampler_cubemap_filter_mode_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_exp_sampler_cubemap_filter_mode_t value) {
-    switch (value) {
-    case UR_EXP_SAMPLER_CUBEMAP_FILTER_MODE_DISJOINTED:
-        os << "UR_EXP_SAMPLER_CUBEMAP_FILTER_MODE_DISJOINTED";
-        break;
-    case UR_EXP_SAMPLER_CUBEMAP_FILTER_MODE_SEAMLESS:
-        os << "UR_EXP_SAMPLER_CUBEMAP_FILTER_MODE_SEAMLESS";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_external_mem_type_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_exp_external_mem_type_t value) {
-    switch (value) {
-    case UR_EXP_EXTERNAL_MEM_TYPE_OPAQUE_FD:
-        os << "UR_EXP_EXTERNAL_MEM_TYPE_OPAQUE_FD";
-        break;
-    case UR_EXP_EXTERNAL_MEM_TYPE_WIN32_NT:
-        os << "UR_EXP_EXTERNAL_MEM_TYPE_WIN32_NT";
-        break;
-    case UR_EXP_EXTERNAL_MEM_TYPE_WIN32_NT_DX12_RESOURCE:
-        os << "UR_EXP_EXTERNAL_MEM_TYPE_WIN32_NT_DX12_RESOURCE";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_external_semaphore_type_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_exp_external_semaphore_type_t value) {
-    switch (value) {
-    case UR_EXP_EXTERNAL_SEMAPHORE_TYPE_OPAQUE_FD:
-        os << "UR_EXP_EXTERNAL_SEMAPHORE_TYPE_OPAQUE_FD";
-        break;
-    case UR_EXP_EXTERNAL_SEMAPHORE_TYPE_WIN32_NT:
-        os << "UR_EXP_EXTERNAL_SEMAPHORE_TYPE_WIN32_NT";
-        break;
-    case UR_EXP_EXTERNAL_SEMAPHORE_TYPE_WIN32_NT_DX12_FENCE:
-        os << "UR_EXP_EXTERNAL_SEMAPHORE_TYPE_WIN32_NT_DX12_FENCE";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_file_descriptor_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_file_descriptor_t params) {
-    os << "(struct ur_exp_file_descriptor_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_kernel_info_t value, size_t size);
 
-    os << ", ";
-    os << ".fd = ";
 
-    os << (params.fd);
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_kernel_group_info_t value, size_t size);
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_win32_handle_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_win32_handle_t params) {
-    os << "(struct ur_exp_win32_handle_t){";
 
-    os << ".stype = ";
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_kernel_sub_group_info_t value, size_t size);
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".handle = ";
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_kernel_exec_info_t value, size_t size);
 
-    ur::details::printPtr(os,
-                          (params.handle));
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_sampler_mip_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_sampler_mip_properties_t params) {
-    os << "(struct ur_exp_sampler_mip_properties_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".minMipmapLevelClamp = ";
 
-    os << (params.minMipmapLevelClamp);
 
-    os << ", ";
-    os << ".maxMipmapLevelClamp = ";
 
-    os << (params.maxMipmapLevelClamp);
 
-    os << ", ";
-    os << ".maxAnisotropy = ";
 
-    os << (params.maxAnisotropy);
 
-    os << ", ";
-    os << ".mipFilterMode = ";
 
-    os << (params.mipFilterMode);
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_sampler_addr_modes_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_sampler_addr_modes_t params) {
-    os << "(struct ur_exp_sampler_addr_modes_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".addrModes = {";
-    for (auto i = 0; i < 3; i++) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        os << (params.addrModes[i]);
-    }
-    os << "}";
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_sampler_cubemap_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_sampler_cubemap_properties_t params) {
-    os << "(struct ur_exp_sampler_cubemap_properties_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".cubemapFilterMode = ";
 
-    os << (params.cubemapFilterMode);
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_external_mem_desc_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_external_mem_desc_t params) {
-    os << "(struct ur_exp_external_mem_desc_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_external_semaphore_desc_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_external_semaphore_desc_t params) {
-    os << "(struct ur_exp_external_semaphore_desc_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_queue_info_t value, size_t size);
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_image_copy_region_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_image_copy_region_t params) {
-    os << "(struct ur_exp_image_copy_region_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
+    template<> inline ur_result_t printFlag<ur_queue_flag_t>(std::ostream &os, uint32_t flag);
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".srcOffset = ";
 
-    os << (params.srcOffset);
 
-    os << ", ";
-    os << ".dstOffset = ";
 
-    os << (params.dstOffset);
 
-    os << ", ";
-    os << ".copyExtent = ";
 
-    os << (params.copyExtent);
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_device_command_buffer_update_capability_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_device_command_buffer_update_capability_flag_t value) {
-    switch (value) {
-    case UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_ARGUMENTS:
-        os << "UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_ARGUMENTS";
-        break;
-    case UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_LOCAL_WORK_SIZE:
-        os << "UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_LOCAL_WORK_SIZE";
-        break;
-    case UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_SIZE:
-        os << "UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_SIZE";
-        break;
-    case UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_OFFSET:
-        os << "UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_OFFSET";
-        break;
-    case UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_HANDLE:
-        os << "UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_HANDLE";
-        break;
-    case UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_EVENTS:
-        os << "UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_EVENTS";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
 
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_device_command_buffer_update_capability_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_device_command_buffer_update_capability_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_ARGUMENTS) == (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_ARGUMENTS) {
-        val ^= (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_ARGUMENTS;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_ARGUMENTS;
-    }
 
-    if ((val & UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_LOCAL_WORK_SIZE) == (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_LOCAL_WORK_SIZE) {
-        val ^= (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_LOCAL_WORK_SIZE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_LOCAL_WORK_SIZE;
-    }
 
-    if ((val & UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_SIZE) == (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_SIZE) {
-        val ^= (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_SIZE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_SIZE;
-    }
 
-    if ((val & UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_OFFSET) == (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_OFFSET) {
-        val ^= (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_OFFSET;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_OFFSET;
-    }
 
-    if ((val & UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_HANDLE) == (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_HANDLE) {
-        val ^= (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_HANDLE;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_HANDLE;
-    }
 
-    if ((val & UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_EVENTS) == (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_EVENTS) {
-        val ^= (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_EVENTS;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_EVENTS;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_command_buffer_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_exp_command_buffer_info_t value) {
-    switch (value) {
-    case UR_EXP_COMMAND_BUFFER_INFO_REFERENCE_COUNT:
-        os << "UR_EXP_COMMAND_BUFFER_INFO_REFERENCE_COUNT";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_exp_command_buffer_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_exp_command_buffer_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
 
-    switch (value) {
-    case UR_EXP_COMMAND_BUFFER_INFO_REFERENCE_COUNT: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_command_buffer_command_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_exp_command_buffer_command_info_t value) {
-    switch (value) {
-    case UR_EXP_COMMAND_BUFFER_COMMAND_INFO_REFERENCE_COUNT:
-        os << "UR_EXP_COMMAND_BUFFER_COMMAND_INFO_REFERENCE_COUNT";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_exp_command_buffer_command_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_exp_command_buffer_command_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
 
-    switch (value) {
-    case UR_EXP_COMMAND_BUFFER_COMMAND_INFO_REFERENCE_COUNT: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_command_buffer_desc_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_command_buffer_desc_t params) {
-    os << "(struct ur_exp_command_buffer_desc_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".isUpdatable = ";
 
-    os << (params.isUpdatable);
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_event_info_t value, size_t size);
 
-    os << ", ";
-    os << ".isInOrder = ";
 
-    os << (params.isInOrder);
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_profiling_info_t value, size_t size);
+
 
-    os << ", ";
-    os << ".enableProfiling = ";
 
-    os << (params.enableProfiling);
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_command_buffer_update_memobj_arg_desc_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_command_buffer_update_memobj_arg_desc_t params) {
-    os << "(struct ur_exp_command_buffer_update_memobj_arg_desc_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".argIndex = ";
 
-    os << (params.argIndex);
 
-    os << ", ";
-    os << ".pProperties = ";
 
-    os << (params.pProperties);
 
-    os << ", ";
-    os << ".hNewMemObjArg = ";
 
-    ur::details::printPtr(os,
-                          (params.hNewMemObjArg));
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_command_buffer_update_pointer_arg_desc_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_command_buffer_update_pointer_arg_desc_t params) {
-    os << "(struct ur_exp_command_buffer_update_pointer_arg_desc_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".argIndex = ";
 
-    os << (params.argIndex);
 
-    os << ", ";
-    os << ".pProperties = ";
 
-    os << (params.pProperties);
 
-    os << ", ";
-    os << ".pNewPointerArg = ";
 
-    os << (params.pNewPointerArg);
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_command_buffer_update_value_arg_desc_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_command_buffer_update_value_arg_desc_t params) {
-    os << "(struct ur_exp_command_buffer_update_value_arg_desc_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".argIndex = ";
 
-    os << (params.argIndex);
 
-    os << ", ";
-    os << ".argSize = ";
 
-    os << (params.argSize);
 
-    os << ", ";
-    os << ".pProperties = ";
 
-    os << (params.pProperties);
 
-    os << ", ";
-    os << ".pNewValueArg = ";
 
-    os << (params.pNewValueArg);
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_command_buffer_update_kernel_launch_desc_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_command_buffer_update_kernel_launch_desc_t params) {
-    os << "(struct ur_exp_command_buffer_update_kernel_launch_desc_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".hNewKernel = ";
 
-    ur::details::printPtr(os,
-                          (params.hNewKernel));
 
-    os << ", ";
-    os << ".numNewMemObjArgs = ";
 
-    os << (params.numNewMemObjArgs);
 
-    os << ", ";
-    os << ".numNewPointerArgs = ";
 
-    os << (params.numNewPointerArgs);
 
-    os << ", ";
-    os << ".numNewValueArgs = ";
 
-    os << (params.numNewValueArgs);
 
-    os << ", ";
-    os << ".newWorkDim = ";
+    template<> inline ur_result_t printFlag<ur_map_flag_t>(std::ostream &os, uint32_t flag);
 
-    os << (params.newWorkDim);
 
-    os << ", ";
-    os << ".pNewMemObjArgList = {";
-    for (size_t i = 0; (params.pNewMemObjArgList) != NULL && i < params.numNewMemObjArgs; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+    template<> inline ur_result_t printFlag<ur_usm_migration_flag_t>(std::ostream &os, uint32_t flag);
 
-        os << ((params.pNewMemObjArgList))[i];
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".pNewPointerArgList = {";
-    for (size_t i = 0; (params.pNewPointerArgList) != NULL && i < params.numNewPointerArgs; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        os << ((params.pNewPointerArgList))[i];
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".pNewValueArgList = {";
-    for (size_t i = 0; (params.pNewValueArgList) != NULL && i < params.numNewValueArgs; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        os << ((params.pNewValueArgList))[i];
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".pNewGlobalWorkOffset = {";
-    for (size_t i = 0; (params.pNewGlobalWorkOffset) != NULL && i < params.newWorkDim; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        os << ((params.pNewGlobalWorkOffset))[i];
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".pNewGlobalWorkSize = {";
-    for (size_t i = 0; (params.pNewGlobalWorkSize) != NULL && i < params.newWorkDim; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        os << ((params.pNewGlobalWorkSize))[i];
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".pNewLocalWorkSize = {";
-    for (size_t i = 0; (params.pNewLocalWorkSize) != NULL && i < params.newWorkDim; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        os << ((params.pNewLocalWorkSize))[i];
-    }
-    os << "}";
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_launch_property_id_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_exp_launch_property_id_t value) {
-    switch (value) {
-    case UR_EXP_LAUNCH_PROPERTY_ID_IGNORE:
-        os << "UR_EXP_LAUNCH_PROPERTY_ID_IGNORE";
-        break;
-    case UR_EXP_LAUNCH_PROPERTY_ID_COOPERATIVE:
-        os << "UR_EXP_LAUNCH_PROPERTY_ID_COOPERATIVE";
-        break;
-    case UR_EXP_LAUNCH_PROPERTY_ID_CLUSTER_DIMENSION:
-        os << "UR_EXP_LAUNCH_PROPERTY_ID_CLUSTER_DIMENSION";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
 
-///////////////////////////////////////////////////////////////////////////////
-// @brief Print ur_exp_launch_property_value_t union
-inline ur_result_t printUnion(
-    std::ostream &os,
-    const union ur_exp_launch_property_value_t params,
-    const enum ur_exp_launch_property_id_t tag) {
-    os << "(union ur_exp_launch_property_value_t){";
 
-    switch (tag) {
-    case UR_EXP_LAUNCH_PROPERTY_ID_CLUSTER_DIMENSION:
 
-        os << ".clusterDim = {";
-        for (auto i = 0; i < 3; i++) {
-            if (i != 0) {
-                os << ", ";
-            }
 
-            os << (params.clusterDim[i]);
-        }
-        os << "}";
 
-        break;
-    case UR_EXP_LAUNCH_PROPERTY_ID_COOPERATIVE:
 
-        os << ".cooperative = ";
 
-        os << (params.cooperative);
 
-        break;
-    default:
-        os << "<unknown>";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    os << "}";
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_launch_property_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_launch_property_t params) {
-    os << "(struct ur_exp_launch_property_t){";
 
-    os << ".id = ";
 
-    os << (params.id);
 
-    os << ", ";
-    os << ".value = ";
-    ur::details::printUnion(os, (params.value), params.id);
 
-    os << "}";
-    return os;
-}
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_peer_info_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_exp_peer_info_t value) {
-    switch (value) {
-    case UR_EXP_PEER_INFO_UR_PEER_ACCESS_SUPPORTED:
-        os << "UR_EXP_PEER_INFO_UR_PEER_ACCESS_SUPPORTED";
-        break;
-    case UR_EXP_PEER_INFO_UR_PEER_ATOMICS_SUPPORTED:
-        os << "UR_EXP_PEER_INFO_UR_PEER_ATOMICS_SUPPORTED";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_exp_peer_info_t enum value
-template <>
-inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_exp_peer_info_t value, size_t size) {
-    if (ptr == NULL) {
-        return printPtr(os, ptr);
-    }
 
-    switch (value) {
-    case UR_EXP_PEER_INFO_UR_PEER_ACCESS_SUPPORTED: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    case UR_EXP_PEER_INFO_UR_PEER_ATOMICS_SUPPORTED: {
-        const uint32_t *tptr = (const uint32_t *)ptr;
-        if (sizeof(uint32_t) > size) {
-            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
-            return UR_RESULT_ERROR_INVALID_SIZE;
-        }
-        os << (const void *)(tptr) << " (";
 
-        os << *tptr;
 
-        os << ")";
-    } break;
-    default:
-        os << "unknown enumerator";
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_enqueue_native_command_flag_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_exp_enqueue_native_command_flag_t value) {
-    switch (value) {
-    case UR_EXP_ENQUEUE_NATIVE_COMMAND_FLAG_TBD:
-        os << "UR_EXP_ENQUEUE_NATIVE_COMMAND_FLAG_TBD";
-        break;
-    default:
-        os << "unknown enumerator";
-        break;
-    }
-    return os;
-}
 
-namespace ur::details {
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_exp_enqueue_native_command_flag_t flag
-template <>
-inline ur_result_t printFlag<ur_exp_enqueue_native_command_flag_t>(std::ostream &os, uint32_t flag) {
-    uint32_t val = flag;
-    bool first = true;
-
-    if ((val & UR_EXP_ENQUEUE_NATIVE_COMMAND_FLAG_TBD) == (uint32_t)UR_EXP_ENQUEUE_NATIVE_COMMAND_FLAG_TBD) {
-        val ^= (uint32_t)UR_EXP_ENQUEUE_NATIVE_COMMAND_FLAG_TBD;
-        if (!first) {
-            os << " | ";
-        } else {
-            first = false;
-        }
-        os << UR_EXP_ENQUEUE_NATIVE_COMMAND_FLAG_TBD;
-    }
-    if (val != 0) {
-        std::bitset<32> bits(val);
-        if (!first) {
-            os << " | ";
-        }
-        os << "unknown bit flags " << bits;
-    } else if (first) {
-        os << "0";
-    }
-    return UR_RESULT_SUCCESS;
-}
-} // namespace ur::details
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_enqueue_native_command_properties_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_enqueue_native_command_properties_t params) {
-    os << "(struct ur_exp_enqueue_native_command_properties_t){";
 
-    os << ".stype = ";
 
-    os << (params.stype);
 
-    os << ", ";
-    os << ".pNext = ";
+    template<> inline ur_result_t printFlag<ur_exp_image_copy_flag_t>(std::ostream &os, uint32_t flag);
 
-    ur::details::printStruct(os,
-                             (params.pNext));
 
-    os << ", ";
-    os << ".flags = ";
 
-    ur::details::printFlag<ur_exp_enqueue_native_command_flag_t>(os,
-                                                                 (params.flags));
 
-    os << "}";
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_loader_config_create_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_loader_config_create_params_t *params) {
 
-    os << ".phLoaderConfig = ";
 
-    ur::details::printPtr(os,
-                          *(params->pphLoaderConfig));
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_loader_config_retain_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_loader_config_retain_params_t *params) {
 
-    os << ".hLoaderConfig = ";
 
-    ur::details::printPtr(os,
-                          *(params->phLoaderConfig));
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_loader_config_release_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_loader_config_release_params_t *params) {
 
-    os << ".hLoaderConfig = ";
 
-    ur::details::printPtr(os,
-                          *(params->phLoaderConfig));
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_loader_config_get_info_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_loader_config_get_info_params_t *params) {
 
-    os << ".hLoaderConfig = ";
 
-    ur::details::printPtr(os,
-                          *(params->phLoaderConfig));
 
-    os << ", ";
-    os << ".propName = ";
 
-    os << *(params->ppropName);
 
-    os << ", ";
-    os << ".propSize = ";
 
-    os << *(params->ppropSize);
 
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".pPropSizeRet = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_loader_config_enable_layer_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_loader_config_enable_layer_params_t *params) {
 
-    os << ".hLoaderConfig = ";
 
-    ur::details::printPtr(os,
-                          *(params->phLoaderConfig));
 
-    os << ", ";
-    os << ".pLayerName = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppLayerName));
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_loader_config_set_code_location_callback_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_loader_config_set_code_location_callback_params_t *params) {
 
-    os << ".hLoaderConfig = ";
 
-    ur::details::printPtr(os,
-                          *(params->phLoaderConfig));
 
-    os << ", ";
-    os << ".pfnCodeloc = ";
 
-    os << reinterpret_cast<void *>(
-        *(params->ppfnCodeloc));
 
-    os << ", ";
-    os << ".pUserData = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppUserData));
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_loader_config_set_mocking_enabled_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_loader_config_set_mocking_enabled_params_t *params) {
 
-    os << ".hLoaderConfig = ";
 
-    ur::details::printPtr(os,
-                          *(params->phLoaderConfig));
 
-    os << ", ";
-    os << ".enable = ";
 
-    os << *(params->penable);
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_platform_get_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_platform_get_params_t *params) {
 
-    os << ".phAdapters = {";
-    for (size_t i = 0; *(params->pphAdapters) != NULL && i < *params->pNumAdapters; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphAdapters))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".NumAdapters = ";
 
-    os << *(params->pNumAdapters);
 
-    os << ", ";
-    os << ".NumEntries = ";
 
-    os << *(params->pNumEntries);
 
-    os << ", ";
-    os << ".phPlatforms = {";
-    for (size_t i = 0; *(params->pphPlatforms) != NULL && i < *params->pNumEntries; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphPlatforms))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".pNumPlatforms = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppNumPlatforms));
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_platform_get_info_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_platform_get_info_params_t *params) {
 
-    os << ".hPlatform = ";
 
-    ur::details::printPtr(os,
-                          *(params->phPlatform));
+    template<> inline ur_result_t printFlag<ur_device_command_buffer_update_capability_flag_t>(std::ostream &os, uint32_t flag);
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_exp_command_buffer_info_t value, size_t size);
 
-    os << ", ";
-    os << ".propName = ";
 
-    os << *(params->ppropName);
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_exp_command_buffer_command_info_t value, size_t size);
 
-    os << ", ";
-    os << ".propSize = ";
 
-    os << *(params->ppropSize);
 
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".pPropSizeRet = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_platform_get_native_handle_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_platform_get_native_handle_params_t *params) {
 
-    os << ".hPlatform = ";
 
-    ur::details::printPtr(os,
-                          *(params->phPlatform));
 
-    os << ", ";
-    os << ".phNativePlatform = ";
 
-    ur::details::printPtr(os,
-                          *(params->pphNativePlatform));
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_platform_create_with_native_handle_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_platform_create_with_native_handle_params_t *params) {
 
-    os << ".hNativePlatform = ";
 
-    ur::details::printPtr(os, reinterpret_cast<void *>(
-                                  *(params->phNativePlatform)));
 
-    os << ", ";
-    os << ".hAdapter = ";
 
-    ur::details::printPtr(os,
-                          *(params->phAdapter));
 
-    os << ", ";
-    os << ".pProperties = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
 
-    os << ", ";
-    os << ".phPlatform = ";
 
-    ur::details::printPtr(os,
-                          *(params->pphPlatform));
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_platform_get_api_version_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_platform_get_api_version_params_t *params) {
 
-    os << ".hPlatform = ";
 
-    ur::details::printPtr(os,
-                          *(params->phPlatform));
 
-    os << ", ";
-    os << ".pVersion = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppVersion));
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_platform_get_backend_option_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_platform_get_backend_option_params_t *params) {
 
-    os << ".hPlatform = ";
 
-    ur::details::printPtr(os,
-                          *(params->phPlatform));
 
-    os << ", ";
-    os << ".pFrontendOption = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppFrontendOption));
 
-    os << ", ";
-    os << ".ppPlatformOption = ";
 
-    ur::details::printPtr(os,
-                          *(params->pppPlatformOption));
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_context_create_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_context_create_params_t *params) {
 
-    os << ".DeviceCount = ";
 
-    os << *(params->pDeviceCount);
 
-    os << ", ";
-    os << ".phDevices = {";
-    for (size_t i = 0; *(params->pphDevices) != NULL && i < *params->pDeviceCount; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphDevices))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".pProperties = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
 
-    os << ", ";
-    os << ".phContext = ";
 
-    ur::details::printPtr(os,
-                          *(params->pphContext));
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_context_retain_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_context_retain_params_t *params) {
 
-    os << ".hContext = ";
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_context_release_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_context_release_params_t *params) {
 
-    os << ".hContext = ";
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_context_get_info_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_context_get_info_params_t *params) {
 
-    os << ".hContext = ";
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
 
-    os << ", ";
-    os << ".propName = ";
 
-    os << *(params->ppropName);
 
-    os << ", ";
-    os << ".propSize = ";
 
-    os << *(params->ppropSize);
 
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".pPropSizeRet = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_context_get_native_handle_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_context_get_native_handle_params_t *params) {
 
-    os << ".hContext = ";
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
 
-    os << ", ";
-    os << ".phNativeContext = ";
 
-    ur::details::printPtr(os,
-                          *(params->pphNativeContext));
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_context_create_with_native_handle_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_context_create_with_native_handle_params_t *params) {
 
-    os << ".hNativeContext = ";
 
-    ur::details::printPtr(os, reinterpret_cast<void *>(
-                                  *(params->phNativeContext)));
 
-    os << ", ";
-    os << ".hAdapter = ";
 
-    ur::details::printPtr(os,
-                          *(params->phAdapter));
 
-    os << ", ";
-    os << ".numDevices = ";
 
-    os << *(params->pnumDevices);
 
-    os << ", ";
-    os << ".phDevices = {";
-    for (size_t i = 0; *(params->pphDevices) != NULL && i < *params->pnumDevices; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphDevices))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".pProperties = ";
+    
+    inline ur_result_t printUnion(
+        std::ostream &os,
+        const union ur_exp_launch_property_value_t params,
+        const enum ur_exp_launch_property_id_t tag
+    );
 
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
 
-    os << ", ";
-    os << ".phContext = ";
 
-    ur::details::printPtr(os,
-                          *(params->pphContext));
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_context_set_extended_deleter_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_context_set_extended_deleter_params_t *params) {
 
-    os << ".hContext = ";
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
 
-    os << ", ";
-    os << ".pfnDeleter = ";
 
-    os << reinterpret_cast<void *>(
-        *(params->ppfnDeleter));
 
-    os << ", ";
-    os << ".pUserData = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppUserData));
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_event_get_info_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_event_get_info_params_t *params) {
 
-    os << ".hEvent = ";
 
-    ur::details::printPtr(os,
-                          *(params->phEvent));
 
-    os << ", ";
-    os << ".propName = ";
 
-    os << *(params->ppropName);
 
-    os << ", ";
-    os << ".propSize = ";
 
-    os << *(params->ppropSize);
+    template <> inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_exp_peer_info_t value, size_t size);
 
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".pPropSizeRet = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_event_get_profiling_info_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_event_get_profiling_info_params_t *params) {
 
-    os << ".hEvent = ";
 
-    ur::details::printPtr(os,
-                          *(params->phEvent));
 
-    os << ", ";
-    os << ".propName = ";
 
-    os << *(params->ppropName);
 
-    os << ", ";
-    os << ".propSize = ";
+    template<> inline ur_result_t printFlag<ur_exp_enqueue_native_command_flag_t>(std::ostream &os, uint32_t flag);
 
-    os << *(params->ppropSize);
 
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".pPropSizeRet = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
-    return os;
-}
 
+} // namespace ur::details
+
+    inline std::ostream &operator<<(std::ostream &os, enum ur_function_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_structure_type_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_result_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_base_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_base_desc_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_rect_offset_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_rect_region_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_init_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_loader_config_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_code_location_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_adapter_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_adapter_backend_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_platform_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_api_version_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_platform_native_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_platform_backend_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_device_binary_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_type_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_affinity_domain_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_partition_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_device_partition_property_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_device_partition_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_fp_capability_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_mem_cache_type_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_local_mem_type_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_exec_capability_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_device_native_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_memory_order_capability_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_memory_scope_capability_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_usm_access_capability_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_context_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_context_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_context_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_context_native_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_mem_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_mem_type_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_mem_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_image_channel_order_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_image_channel_type_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_image_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_image_format_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_image_desc_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_buffer_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_buffer_channel_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_buffer_alloc_location_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_buffer_region_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_buffer_create_type_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_native_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_sampler_filter_mode_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_sampler_addressing_mode_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_sampler_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_sampler_desc_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_sampler_native_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_usm_host_mem_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_usm_device_mem_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_usm_pool_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_usm_type_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_usm_alloc_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_usm_advice_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_desc_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_host_desc_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_device_desc_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_alloc_location_desc_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_pool_desc_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_pool_limits_desc_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_usm_pool_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_virtual_mem_granularity_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_virtual_mem_access_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_virtual_mem_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_physical_mem_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_physical_mem_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_program_metadata_type_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_metadata_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_program_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_program_build_status_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_program_binary_type_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_program_build_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_specialization_constant_info_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_native_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_arg_value_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_arg_local_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_kernel_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_kernel_group_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_kernel_sub_group_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_kernel_cache_config_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_kernel_exec_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_arg_pointer_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_exec_info_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_arg_sampler_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_arg_mem_obj_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_native_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_queue_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_queue_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_index_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_native_desc_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_native_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_command_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_event_status_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_event_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_profiling_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_event_native_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_execution_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_map_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_usm_migration_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_exp_image_copy_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_exp_sampler_cubemap_filter_mode_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_exp_external_mem_type_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_exp_external_semaphore_type_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_file_descriptor_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_win32_handle_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_sampler_mip_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_sampler_addr_modes_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_sampler_cubemap_properties_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_external_mem_desc_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_external_semaphore_desc_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_image_copy_region_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_command_buffer_update_capability_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_exp_command_buffer_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_exp_command_buffer_command_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_command_buffer_desc_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_command_buffer_update_memobj_arg_desc_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_command_buffer_update_pointer_arg_desc_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_command_buffer_update_value_arg_desc_t params);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_command_buffer_update_kernel_launch_desc_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_exp_launch_property_id_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_launch_property_t params);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_exp_peer_info_t value);
+    inline std::ostream &operator<<(std::ostream &os, enum ur_exp_enqueue_native_command_flag_t value);
+    inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_enqueue_native_command_properties_t params);
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_function_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_function_t value) {
+        switch (value) {
+                case UR_FUNCTION_CONTEXT_CREATE:
+                    os << "UR_FUNCTION_CONTEXT_CREATE";
+                    break;
+                case UR_FUNCTION_CONTEXT_RETAIN:
+                    os << "UR_FUNCTION_CONTEXT_RETAIN";
+                    break;
+                case UR_FUNCTION_CONTEXT_RELEASE:
+                    os << "UR_FUNCTION_CONTEXT_RELEASE";
+                    break;
+                case UR_FUNCTION_CONTEXT_GET_INFO:
+                    os << "UR_FUNCTION_CONTEXT_GET_INFO";
+                    break;
+                case UR_FUNCTION_CONTEXT_GET_NATIVE_HANDLE:
+                    os << "UR_FUNCTION_CONTEXT_GET_NATIVE_HANDLE";
+                    break;
+                case UR_FUNCTION_CONTEXT_CREATE_WITH_NATIVE_HANDLE:
+                    os << "UR_FUNCTION_CONTEXT_CREATE_WITH_NATIVE_HANDLE";
+                    break;
+                case UR_FUNCTION_CONTEXT_SET_EXTENDED_DELETER:
+                    os << "UR_FUNCTION_CONTEXT_SET_EXTENDED_DELETER";
+                    break;
+                case UR_FUNCTION_DEVICE_GET:
+                    os << "UR_FUNCTION_DEVICE_GET";
+                    break;
+                case UR_FUNCTION_DEVICE_GET_INFO:
+                    os << "UR_FUNCTION_DEVICE_GET_INFO";
+                    break;
+                case UR_FUNCTION_DEVICE_RETAIN:
+                    os << "UR_FUNCTION_DEVICE_RETAIN";
+                    break;
+                case UR_FUNCTION_DEVICE_RELEASE:
+                    os << "UR_FUNCTION_DEVICE_RELEASE";
+                    break;
+                case UR_FUNCTION_DEVICE_PARTITION:
+                    os << "UR_FUNCTION_DEVICE_PARTITION";
+                    break;
+                case UR_FUNCTION_DEVICE_SELECT_BINARY:
+                    os << "UR_FUNCTION_DEVICE_SELECT_BINARY";
+                    break;
+                case UR_FUNCTION_DEVICE_GET_NATIVE_HANDLE:
+                    os << "UR_FUNCTION_DEVICE_GET_NATIVE_HANDLE";
+                    break;
+                case UR_FUNCTION_DEVICE_CREATE_WITH_NATIVE_HANDLE:
+                    os << "UR_FUNCTION_DEVICE_CREATE_WITH_NATIVE_HANDLE";
+                    break;
+                case UR_FUNCTION_DEVICE_GET_GLOBAL_TIMESTAMPS:
+                    os << "UR_FUNCTION_DEVICE_GET_GLOBAL_TIMESTAMPS";
+                    break;
+                case UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH:
+                    os << "UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH";
+                    break;
+                case UR_FUNCTION_ENQUEUE_EVENTS_WAIT:
+                    os << "UR_FUNCTION_ENQUEUE_EVENTS_WAIT";
+                    break;
+                case UR_FUNCTION_ENQUEUE_EVENTS_WAIT_WITH_BARRIER:
+                    os << "UR_FUNCTION_ENQUEUE_EVENTS_WAIT_WITH_BARRIER";
+                    break;
+                case UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ:
+                    os << "UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ";
+                    break;
+                case UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE:
+                    os << "UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE";
+                    break;
+                case UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ_RECT:
+                    os << "UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ_RECT";
+                    break;
+                case UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE_RECT:
+                    os << "UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE_RECT";
+                    break;
+                case UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY:
+                    os << "UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY";
+                    break;
+                case UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY_RECT:
+                    os << "UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY_RECT";
+                    break;
+                case UR_FUNCTION_ENQUEUE_MEM_BUFFER_FILL:
+                    os << "UR_FUNCTION_ENQUEUE_MEM_BUFFER_FILL";
+                    break;
+                case UR_FUNCTION_ENQUEUE_MEM_IMAGE_READ:
+                    os << "UR_FUNCTION_ENQUEUE_MEM_IMAGE_READ";
+                    break;
+                case UR_FUNCTION_ENQUEUE_MEM_IMAGE_WRITE:
+                    os << "UR_FUNCTION_ENQUEUE_MEM_IMAGE_WRITE";
+                    break;
+                case UR_FUNCTION_ENQUEUE_MEM_IMAGE_COPY:
+                    os << "UR_FUNCTION_ENQUEUE_MEM_IMAGE_COPY";
+                    break;
+                case UR_FUNCTION_ENQUEUE_MEM_BUFFER_MAP:
+                    os << "UR_FUNCTION_ENQUEUE_MEM_BUFFER_MAP";
+                    break;
+                case UR_FUNCTION_ENQUEUE_MEM_UNMAP:
+                    os << "UR_FUNCTION_ENQUEUE_MEM_UNMAP";
+                    break;
+                case UR_FUNCTION_ENQUEUE_USM_FILL:
+                    os << "UR_FUNCTION_ENQUEUE_USM_FILL";
+                    break;
+                case UR_FUNCTION_ENQUEUE_USM_MEMCPY:
+                    os << "UR_FUNCTION_ENQUEUE_USM_MEMCPY";
+                    break;
+                case UR_FUNCTION_ENQUEUE_USM_PREFETCH:
+                    os << "UR_FUNCTION_ENQUEUE_USM_PREFETCH";
+                    break;
+                case UR_FUNCTION_ENQUEUE_USM_ADVISE:
+                    os << "UR_FUNCTION_ENQUEUE_USM_ADVISE";
+                    break;
+                case UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_WRITE:
+                    os << "UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_WRITE";
+                    break;
+                case UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_READ:
+                    os << "UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_READ";
+                    break;
+                case UR_FUNCTION_EVENT_GET_INFO:
+                    os << "UR_FUNCTION_EVENT_GET_INFO";
+                    break;
+                case UR_FUNCTION_EVENT_GET_PROFILING_INFO:
+                    os << "UR_FUNCTION_EVENT_GET_PROFILING_INFO";
+                    break;
+                case UR_FUNCTION_EVENT_WAIT:
+                    os << "UR_FUNCTION_EVENT_WAIT";
+                    break;
+                case UR_FUNCTION_EVENT_RETAIN:
+                    os << "UR_FUNCTION_EVENT_RETAIN";
+                    break;
+                case UR_FUNCTION_EVENT_RELEASE:
+                    os << "UR_FUNCTION_EVENT_RELEASE";
+                    break;
+                case UR_FUNCTION_EVENT_GET_NATIVE_HANDLE:
+                    os << "UR_FUNCTION_EVENT_GET_NATIVE_HANDLE";
+                    break;
+                case UR_FUNCTION_EVENT_CREATE_WITH_NATIVE_HANDLE:
+                    os << "UR_FUNCTION_EVENT_CREATE_WITH_NATIVE_HANDLE";
+                    break;
+                case UR_FUNCTION_EVENT_SET_CALLBACK:
+                    os << "UR_FUNCTION_EVENT_SET_CALLBACK";
+                    break;
+                case UR_FUNCTION_KERNEL_CREATE:
+                    os << "UR_FUNCTION_KERNEL_CREATE";
+                    break;
+                case UR_FUNCTION_KERNEL_SET_ARG_VALUE:
+                    os << "UR_FUNCTION_KERNEL_SET_ARG_VALUE";
+                    break;
+                case UR_FUNCTION_KERNEL_SET_ARG_LOCAL:
+                    os << "UR_FUNCTION_KERNEL_SET_ARG_LOCAL";
+                    break;
+                case UR_FUNCTION_KERNEL_GET_INFO:
+                    os << "UR_FUNCTION_KERNEL_GET_INFO";
+                    break;
+                case UR_FUNCTION_KERNEL_GET_GROUP_INFO:
+                    os << "UR_FUNCTION_KERNEL_GET_GROUP_INFO";
+                    break;
+                case UR_FUNCTION_KERNEL_GET_SUB_GROUP_INFO:
+                    os << "UR_FUNCTION_KERNEL_GET_SUB_GROUP_INFO";
+                    break;
+                case UR_FUNCTION_KERNEL_RETAIN:
+                    os << "UR_FUNCTION_KERNEL_RETAIN";
+                    break;
+                case UR_FUNCTION_KERNEL_RELEASE:
+                    os << "UR_FUNCTION_KERNEL_RELEASE";
+                    break;
+                case UR_FUNCTION_KERNEL_SET_ARG_POINTER:
+                    os << "UR_FUNCTION_KERNEL_SET_ARG_POINTER";
+                    break;
+                case UR_FUNCTION_KERNEL_SET_EXEC_INFO:
+                    os << "UR_FUNCTION_KERNEL_SET_EXEC_INFO";
+                    break;
+                case UR_FUNCTION_KERNEL_SET_ARG_SAMPLER:
+                    os << "UR_FUNCTION_KERNEL_SET_ARG_SAMPLER";
+                    break;
+                case UR_FUNCTION_KERNEL_SET_ARG_MEM_OBJ:
+                    os << "UR_FUNCTION_KERNEL_SET_ARG_MEM_OBJ";
+                    break;
+                case UR_FUNCTION_KERNEL_SET_SPECIALIZATION_CONSTANTS:
+                    os << "UR_FUNCTION_KERNEL_SET_SPECIALIZATION_CONSTANTS";
+                    break;
+                case UR_FUNCTION_KERNEL_GET_NATIVE_HANDLE:
+                    os << "UR_FUNCTION_KERNEL_GET_NATIVE_HANDLE";
+                    break;
+                case UR_FUNCTION_KERNEL_CREATE_WITH_NATIVE_HANDLE:
+                    os << "UR_FUNCTION_KERNEL_CREATE_WITH_NATIVE_HANDLE";
+                    break;
+                case UR_FUNCTION_MEM_IMAGE_CREATE:
+                    os << "UR_FUNCTION_MEM_IMAGE_CREATE";
+                    break;
+                case UR_FUNCTION_MEM_BUFFER_CREATE:
+                    os << "UR_FUNCTION_MEM_BUFFER_CREATE";
+                    break;
+                case UR_FUNCTION_MEM_RETAIN:
+                    os << "UR_FUNCTION_MEM_RETAIN";
+                    break;
+                case UR_FUNCTION_MEM_RELEASE:
+                    os << "UR_FUNCTION_MEM_RELEASE";
+                    break;
+                case UR_FUNCTION_MEM_BUFFER_PARTITION:
+                    os << "UR_FUNCTION_MEM_BUFFER_PARTITION";
+                    break;
+                case UR_FUNCTION_MEM_GET_NATIVE_HANDLE:
+                    os << "UR_FUNCTION_MEM_GET_NATIVE_HANDLE";
+                    break;
+                case UR_FUNCTION_ENQUEUE_READ_HOST_PIPE:
+                    os << "UR_FUNCTION_ENQUEUE_READ_HOST_PIPE";
+                    break;
+                case UR_FUNCTION_MEM_GET_INFO:
+                    os << "UR_FUNCTION_MEM_GET_INFO";
+                    break;
+                case UR_FUNCTION_MEM_IMAGE_GET_INFO:
+                    os << "UR_FUNCTION_MEM_IMAGE_GET_INFO";
+                    break;
+                case UR_FUNCTION_PLATFORM_GET:
+                    os << "UR_FUNCTION_PLATFORM_GET";
+                    break;
+                case UR_FUNCTION_PLATFORM_GET_INFO:
+                    os << "UR_FUNCTION_PLATFORM_GET_INFO";
+                    break;
+                case UR_FUNCTION_PLATFORM_GET_API_VERSION:
+                    os << "UR_FUNCTION_PLATFORM_GET_API_VERSION";
+                    break;
+                case UR_FUNCTION_PLATFORM_GET_NATIVE_HANDLE:
+                    os << "UR_FUNCTION_PLATFORM_GET_NATIVE_HANDLE";
+                    break;
+                case UR_FUNCTION_PLATFORM_CREATE_WITH_NATIVE_HANDLE:
+                    os << "UR_FUNCTION_PLATFORM_CREATE_WITH_NATIVE_HANDLE";
+                    break;
+                case UR_FUNCTION_PROGRAM_CREATE_WITH_IL:
+                    os << "UR_FUNCTION_PROGRAM_CREATE_WITH_IL";
+                    break;
+                case UR_FUNCTION_PROGRAM_CREATE_WITH_BINARY:
+                    os << "UR_FUNCTION_PROGRAM_CREATE_WITH_BINARY";
+                    break;
+                case UR_FUNCTION_PROGRAM_BUILD:
+                    os << "UR_FUNCTION_PROGRAM_BUILD";
+                    break;
+                case UR_FUNCTION_PROGRAM_COMPILE:
+                    os << "UR_FUNCTION_PROGRAM_COMPILE";
+                    break;
+                case UR_FUNCTION_PROGRAM_LINK:
+                    os << "UR_FUNCTION_PROGRAM_LINK";
+                    break;
+                case UR_FUNCTION_PROGRAM_RETAIN:
+                    os << "UR_FUNCTION_PROGRAM_RETAIN";
+                    break;
+                case UR_FUNCTION_PROGRAM_RELEASE:
+                    os << "UR_FUNCTION_PROGRAM_RELEASE";
+                    break;
+                case UR_FUNCTION_PROGRAM_GET_FUNCTION_POINTER:
+                    os << "UR_FUNCTION_PROGRAM_GET_FUNCTION_POINTER";
+                    break;
+                case UR_FUNCTION_PROGRAM_GET_INFO:
+                    os << "UR_FUNCTION_PROGRAM_GET_INFO";
+                    break;
+                case UR_FUNCTION_PROGRAM_GET_BUILD_INFO:
+                    os << "UR_FUNCTION_PROGRAM_GET_BUILD_INFO";
+                    break;
+                case UR_FUNCTION_PROGRAM_SET_SPECIALIZATION_CONSTANTS:
+                    os << "UR_FUNCTION_PROGRAM_SET_SPECIALIZATION_CONSTANTS";
+                    break;
+                case UR_FUNCTION_PROGRAM_GET_NATIVE_HANDLE:
+                    os << "UR_FUNCTION_PROGRAM_GET_NATIVE_HANDLE";
+                    break;
+                case UR_FUNCTION_PROGRAM_CREATE_WITH_NATIVE_HANDLE:
+                    os << "UR_FUNCTION_PROGRAM_CREATE_WITH_NATIVE_HANDLE";
+                    break;
+                case UR_FUNCTION_QUEUE_GET_INFO:
+                    os << "UR_FUNCTION_QUEUE_GET_INFO";
+                    break;
+                case UR_FUNCTION_QUEUE_CREATE:
+                    os << "UR_FUNCTION_QUEUE_CREATE";
+                    break;
+                case UR_FUNCTION_QUEUE_RETAIN:
+                    os << "UR_FUNCTION_QUEUE_RETAIN";
+                    break;
+                case UR_FUNCTION_QUEUE_RELEASE:
+                    os << "UR_FUNCTION_QUEUE_RELEASE";
+                    break;
+                case UR_FUNCTION_QUEUE_GET_NATIVE_HANDLE:
+                    os << "UR_FUNCTION_QUEUE_GET_NATIVE_HANDLE";
+                    break;
+                case UR_FUNCTION_QUEUE_CREATE_WITH_NATIVE_HANDLE:
+                    os << "UR_FUNCTION_QUEUE_CREATE_WITH_NATIVE_HANDLE";
+                    break;
+                case UR_FUNCTION_QUEUE_FINISH:
+                    os << "UR_FUNCTION_QUEUE_FINISH";
+                    break;
+                case UR_FUNCTION_QUEUE_FLUSH:
+                    os << "UR_FUNCTION_QUEUE_FLUSH";
+                    break;
+                case UR_FUNCTION_SAMPLER_CREATE:
+                    os << "UR_FUNCTION_SAMPLER_CREATE";
+                    break;
+                case UR_FUNCTION_SAMPLER_RETAIN:
+                    os << "UR_FUNCTION_SAMPLER_RETAIN";
+                    break;
+                case UR_FUNCTION_SAMPLER_RELEASE:
+                    os << "UR_FUNCTION_SAMPLER_RELEASE";
+                    break;
+                case UR_FUNCTION_SAMPLER_GET_INFO:
+                    os << "UR_FUNCTION_SAMPLER_GET_INFO";
+                    break;
+                case UR_FUNCTION_SAMPLER_GET_NATIVE_HANDLE:
+                    os << "UR_FUNCTION_SAMPLER_GET_NATIVE_HANDLE";
+                    break;
+                case UR_FUNCTION_SAMPLER_CREATE_WITH_NATIVE_HANDLE:
+                    os << "UR_FUNCTION_SAMPLER_CREATE_WITH_NATIVE_HANDLE";
+                    break;
+                case UR_FUNCTION_USM_HOST_ALLOC:
+                    os << "UR_FUNCTION_USM_HOST_ALLOC";
+                    break;
+                case UR_FUNCTION_USM_DEVICE_ALLOC:
+                    os << "UR_FUNCTION_USM_DEVICE_ALLOC";
+                    break;
+                case UR_FUNCTION_USM_SHARED_ALLOC:
+                    os << "UR_FUNCTION_USM_SHARED_ALLOC";
+                    break;
+                case UR_FUNCTION_USM_FREE:
+                    os << "UR_FUNCTION_USM_FREE";
+                    break;
+                case UR_FUNCTION_USM_GET_MEM_ALLOC_INFO:
+                    os << "UR_FUNCTION_USM_GET_MEM_ALLOC_INFO";
+                    break;
+                case UR_FUNCTION_USM_POOL_CREATE:
+                    os << "UR_FUNCTION_USM_POOL_CREATE";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_CREATE_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_CREATE_EXP";
+                    break;
+                case UR_FUNCTION_PLATFORM_GET_BACKEND_OPTION:
+                    os << "UR_FUNCTION_PLATFORM_GET_BACKEND_OPTION";
+                    break;
+                case UR_FUNCTION_MEM_BUFFER_CREATE_WITH_NATIVE_HANDLE:
+                    os << "UR_FUNCTION_MEM_BUFFER_CREATE_WITH_NATIVE_HANDLE";
+                    break;
+                case UR_FUNCTION_MEM_IMAGE_CREATE_WITH_NATIVE_HANDLE:
+                    os << "UR_FUNCTION_MEM_IMAGE_CREATE_WITH_NATIVE_HANDLE";
+                    break;
+                case UR_FUNCTION_ENQUEUE_WRITE_HOST_PIPE:
+                    os << "UR_FUNCTION_ENQUEUE_WRITE_HOST_PIPE";
+                    break;
+                case UR_FUNCTION_USM_POOL_RETAIN:
+                    os << "UR_FUNCTION_USM_POOL_RETAIN";
+                    break;
+                case UR_FUNCTION_USM_POOL_RELEASE:
+                    os << "UR_FUNCTION_USM_POOL_RELEASE";
+                    break;
+                case UR_FUNCTION_USM_POOL_GET_INFO:
+                    os << "UR_FUNCTION_USM_POOL_GET_INFO";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_RETAIN_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_RETAIN_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_RELEASE_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_RELEASE_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_FINALIZE_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_FINALIZE_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_APPEND_KERNEL_LAUNCH_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_KERNEL_LAUNCH_EXP";
+                    break;
+                case UR_FUNCTION_USM_PITCHED_ALLOC_EXP:
+                    os << "UR_FUNCTION_USM_PITCHED_ALLOC_EXP";
+                    break;
+                case UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_HANDLE_DESTROY_EXP:
+                    os << "UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_HANDLE_DESTROY_EXP";
+                    break;
+                case UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_HANDLE_DESTROY_EXP:
+                    os << "UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_HANDLE_DESTROY_EXP";
+                    break;
+                case UR_FUNCTION_BINDLESS_IMAGES_IMAGE_ALLOCATE_EXP:
+                    os << "UR_FUNCTION_BINDLESS_IMAGES_IMAGE_ALLOCATE_EXP";
+                    break;
+                case UR_FUNCTION_BINDLESS_IMAGES_IMAGE_FREE_EXP:
+                    os << "UR_FUNCTION_BINDLESS_IMAGES_IMAGE_FREE_EXP";
+                    break;
+                case UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_CREATE_EXP:
+                    os << "UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_CREATE_EXP";
+                    break;
+                case UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_CREATE_EXP:
+                    os << "UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_CREATE_EXP";
+                    break;
+                case UR_FUNCTION_BINDLESS_IMAGES_IMAGE_COPY_EXP:
+                    os << "UR_FUNCTION_BINDLESS_IMAGES_IMAGE_COPY_EXP";
+                    break;
+                case UR_FUNCTION_BINDLESS_IMAGES_IMAGE_GET_INFO_EXP:
+                    os << "UR_FUNCTION_BINDLESS_IMAGES_IMAGE_GET_INFO_EXP";
+                    break;
+                case UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_GET_LEVEL_EXP:
+                    os << "UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_GET_LEVEL_EXP";
+                    break;
+                case UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_FREE_EXP:
+                    os << "UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_FREE_EXP";
+                    break;
+                case UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_ARRAY_EXP:
+                    os << "UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_ARRAY_EXP";
+                    break;
+                case UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_SEMAPHORE_EXP:
+                    os << "UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_SEMAPHORE_EXP";
+                    break;
+                case UR_FUNCTION_BINDLESS_IMAGES_WAIT_EXTERNAL_SEMAPHORE_EXP:
+                    os << "UR_FUNCTION_BINDLESS_IMAGES_WAIT_EXTERNAL_SEMAPHORE_EXP";
+                    break;
+                case UR_FUNCTION_BINDLESS_IMAGES_SIGNAL_EXTERNAL_SEMAPHORE_EXP:
+                    os << "UR_FUNCTION_BINDLESS_IMAGES_SIGNAL_EXTERNAL_SEMAPHORE_EXP";
+                    break;
+                case UR_FUNCTION_ENQUEUE_USM_FILL_2D:
+                    os << "UR_FUNCTION_ENQUEUE_USM_FILL_2D";
+                    break;
+                case UR_FUNCTION_ENQUEUE_USM_MEMCPY_2D:
+                    os << "UR_FUNCTION_ENQUEUE_USM_MEMCPY_2D";
+                    break;
+                case UR_FUNCTION_VIRTUAL_MEM_GRANULARITY_GET_INFO:
+                    os << "UR_FUNCTION_VIRTUAL_MEM_GRANULARITY_GET_INFO";
+                    break;
+                case UR_FUNCTION_VIRTUAL_MEM_RESERVE:
+                    os << "UR_FUNCTION_VIRTUAL_MEM_RESERVE";
+                    break;
+                case UR_FUNCTION_VIRTUAL_MEM_FREE:
+                    os << "UR_FUNCTION_VIRTUAL_MEM_FREE";
+                    break;
+                case UR_FUNCTION_VIRTUAL_MEM_MAP:
+                    os << "UR_FUNCTION_VIRTUAL_MEM_MAP";
+                    break;
+                case UR_FUNCTION_VIRTUAL_MEM_UNMAP:
+                    os << "UR_FUNCTION_VIRTUAL_MEM_UNMAP";
+                    break;
+                case UR_FUNCTION_VIRTUAL_MEM_SET_ACCESS:
+                    os << "UR_FUNCTION_VIRTUAL_MEM_SET_ACCESS";
+                    break;
+                case UR_FUNCTION_VIRTUAL_MEM_GET_INFO:
+                    os << "UR_FUNCTION_VIRTUAL_MEM_GET_INFO";
+                    break;
+                case UR_FUNCTION_PHYSICAL_MEM_CREATE:
+                    os << "UR_FUNCTION_PHYSICAL_MEM_CREATE";
+                    break;
+                case UR_FUNCTION_PHYSICAL_MEM_RETAIN:
+                    os << "UR_FUNCTION_PHYSICAL_MEM_RETAIN";
+                    break;
+                case UR_FUNCTION_PHYSICAL_MEM_RELEASE:
+                    os << "UR_FUNCTION_PHYSICAL_MEM_RELEASE";
+                    break;
+                case UR_FUNCTION_USM_IMPORT_EXP:
+                    os << "UR_FUNCTION_USM_IMPORT_EXP";
+                    break;
+                case UR_FUNCTION_USM_RELEASE_EXP:
+                    os << "UR_FUNCTION_USM_RELEASE_EXP";
+                    break;
+                case UR_FUNCTION_USM_P2P_ENABLE_PEER_ACCESS_EXP:
+                    os << "UR_FUNCTION_USM_P2P_ENABLE_PEER_ACCESS_EXP";
+                    break;
+                case UR_FUNCTION_USM_P2P_DISABLE_PEER_ACCESS_EXP:
+                    os << "UR_FUNCTION_USM_P2P_DISABLE_PEER_ACCESS_EXP";
+                    break;
+                case UR_FUNCTION_USM_P2P_PEER_ACCESS_GET_INFO_EXP:
+                    os << "UR_FUNCTION_USM_P2P_PEER_ACCESS_GET_INFO_EXP";
+                    break;
+                case UR_FUNCTION_LOADER_CONFIG_CREATE:
+                    os << "UR_FUNCTION_LOADER_CONFIG_CREATE";
+                    break;
+                case UR_FUNCTION_LOADER_CONFIG_RELEASE:
+                    os << "UR_FUNCTION_LOADER_CONFIG_RELEASE";
+                    break;
+                case UR_FUNCTION_LOADER_CONFIG_RETAIN:
+                    os << "UR_FUNCTION_LOADER_CONFIG_RETAIN";
+                    break;
+                case UR_FUNCTION_LOADER_CONFIG_GET_INFO:
+                    os << "UR_FUNCTION_LOADER_CONFIG_GET_INFO";
+                    break;
+                case UR_FUNCTION_LOADER_CONFIG_ENABLE_LAYER:
+                    os << "UR_FUNCTION_LOADER_CONFIG_ENABLE_LAYER";
+                    break;
+                case UR_FUNCTION_ADAPTER_RELEASE:
+                    os << "UR_FUNCTION_ADAPTER_RELEASE";
+                    break;
+                case UR_FUNCTION_ADAPTER_GET:
+                    os << "UR_FUNCTION_ADAPTER_GET";
+                    break;
+                case UR_FUNCTION_ADAPTER_RETAIN:
+                    os << "UR_FUNCTION_ADAPTER_RETAIN";
+                    break;
+                case UR_FUNCTION_ADAPTER_GET_LAST_ERROR:
+                    os << "UR_FUNCTION_ADAPTER_GET_LAST_ERROR";
+                    break;
+                case UR_FUNCTION_ADAPTER_GET_INFO:
+                    os << "UR_FUNCTION_ADAPTER_GET_INFO";
+                    break;
+                case UR_FUNCTION_PROGRAM_BUILD_EXP:
+                    os << "UR_FUNCTION_PROGRAM_BUILD_EXP";
+                    break;
+                case UR_FUNCTION_PROGRAM_COMPILE_EXP:
+                    os << "UR_FUNCTION_PROGRAM_COMPILE_EXP";
+                    break;
+                case UR_FUNCTION_PROGRAM_LINK_EXP:
+                    os << "UR_FUNCTION_PROGRAM_LINK_EXP";
+                    break;
+                case UR_FUNCTION_LOADER_CONFIG_SET_CODE_LOCATION_CALLBACK:
+                    os << "UR_FUNCTION_LOADER_CONFIG_SET_CODE_LOCATION_CALLBACK";
+                    break;
+                case UR_FUNCTION_LOADER_INIT:
+                    os << "UR_FUNCTION_LOADER_INIT";
+                    break;
+                case UR_FUNCTION_LOADER_TEAR_DOWN:
+                    os << "UR_FUNCTION_LOADER_TEAR_DOWN";
+                    break;
+                case UR_FUNCTION_ENQUEUE_COOPERATIVE_KERNEL_LAUNCH_EXP:
+                    os << "UR_FUNCTION_ENQUEUE_COOPERATIVE_KERNEL_LAUNCH_EXP";
+                    break;
+                case UR_FUNCTION_KERNEL_SUGGEST_MAX_COOPERATIVE_GROUP_COUNT_EXP:
+                    os << "UR_FUNCTION_KERNEL_SUGGEST_MAX_COOPERATIVE_GROUP_COUNT_EXP";
+                    break;
+                case UR_FUNCTION_PROGRAM_GET_GLOBAL_VARIABLE_POINTER:
+                    os << "UR_FUNCTION_PROGRAM_GET_GLOBAL_VARIABLE_POINTER";
+                    break;
+                case UR_FUNCTION_DEVICE_GET_SELECTED:
+                    os << "UR_FUNCTION_DEVICE_GET_SELECTED";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_RETAIN_COMMAND_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_RETAIN_COMMAND_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_RELEASE_COMMAND_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_RELEASE_COMMAND_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_UPDATE_KERNEL_LAUNCH_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_UPDATE_KERNEL_LAUNCH_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_GET_INFO_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_GET_INFO_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_COMMAND_GET_INFO_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_COMMAND_GET_INFO_EXP";
+                    break;
+                case UR_FUNCTION_ENQUEUE_TIMESTAMP_RECORDING_EXP:
+                    os << "UR_FUNCTION_ENQUEUE_TIMESTAMP_RECORDING_EXP";
+                    break;
+                case UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH_CUSTOM_EXP:
+                    os << "UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH_CUSTOM_EXP";
+                    break;
+                case UR_FUNCTION_KERNEL_GET_SUGGESTED_LOCAL_WORK_SIZE:
+                    os << "UR_FUNCTION_KERNEL_GET_SUGGESTED_LOCAL_WORK_SIZE";
+                    break;
+                case UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_MEMORY_EXP:
+                    os << "UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_MEMORY_EXP";
+                    break;
+                case UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_SEMAPHORE_EXP:
+                    os << "UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_SEMAPHORE_EXP";
+                    break;
+                case UR_FUNCTION_ENQUEUE_NATIVE_COMMAND_EXP:
+                    os << "UR_FUNCTION_ENQUEUE_NATIVE_COMMAND_EXP";
+                    break;
+                case UR_FUNCTION_LOADER_CONFIG_SET_MOCKING_ENABLED:
+                    os << "UR_FUNCTION_LOADER_CONFIG_SET_MOCKING_ENABLED";
+                    break;
+                case UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_MEMORY_EXP:
+                    os << "UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_MEMORY_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_MEMCPY_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_MEMCPY_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_FILL_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_FILL_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_RECT_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_RECT_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_RECT_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_RECT_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_RECT_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_RECT_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_FILL_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_FILL_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_PREFETCH_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_PREFETCH_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_ADVISE_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_ADVISE_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_ENQUEUE_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_ENQUEUE_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_UPDATE_SIGNAL_EVENT_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_UPDATE_SIGNAL_EVENT_EXP";
+                    break;
+                case UR_FUNCTION_COMMAND_BUFFER_UPDATE_WAIT_EVENTS_EXP:
+                    os << "UR_FUNCTION_COMMAND_BUFFER_UPDATE_WAIT_EVENTS_EXP";
+                    break;
+                case UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_LINEAR_MEMORY_EXP:
+                    os << "UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_LINEAR_MEMORY_EXP";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_structure_type_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_structure_type_t value) {
+        switch (value) {
+                case UR_STRUCTURE_TYPE_CONTEXT_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_CONTEXT_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_IMAGE_DESC:
+                    os << "UR_STRUCTURE_TYPE_IMAGE_DESC";
+                    break;
+                case UR_STRUCTURE_TYPE_BUFFER_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_BUFFER_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_BUFFER_REGION:
+                    os << "UR_STRUCTURE_TYPE_BUFFER_REGION";
+                    break;
+                case UR_STRUCTURE_TYPE_BUFFER_CHANNEL_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_BUFFER_CHANNEL_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_BUFFER_ALLOC_LOCATION_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_BUFFER_ALLOC_LOCATION_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_USM_DESC:
+                    os << "UR_STRUCTURE_TYPE_USM_DESC";
+                    break;
+                case UR_STRUCTURE_TYPE_USM_HOST_DESC:
+                    os << "UR_STRUCTURE_TYPE_USM_HOST_DESC";
+                    break;
+                case UR_STRUCTURE_TYPE_USM_DEVICE_DESC:
+                    os << "UR_STRUCTURE_TYPE_USM_DEVICE_DESC";
+                    break;
+                case UR_STRUCTURE_TYPE_USM_POOL_DESC:
+                    os << "UR_STRUCTURE_TYPE_USM_POOL_DESC";
+                    break;
+                case UR_STRUCTURE_TYPE_USM_POOL_LIMITS_DESC:
+                    os << "UR_STRUCTURE_TYPE_USM_POOL_LIMITS_DESC";
+                    break;
+                case UR_STRUCTURE_TYPE_DEVICE_BINARY:
+                    os << "UR_STRUCTURE_TYPE_DEVICE_BINARY";
+                    break;
+                case UR_STRUCTURE_TYPE_SAMPLER_DESC:
+                    os << "UR_STRUCTURE_TYPE_SAMPLER_DESC";
+                    break;
+                case UR_STRUCTURE_TYPE_QUEUE_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_QUEUE_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_QUEUE_INDEX_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_QUEUE_INDEX_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_CONTEXT_NATIVE_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_CONTEXT_NATIVE_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_KERNEL_NATIVE_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_KERNEL_NATIVE_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_QUEUE_NATIVE_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_QUEUE_NATIVE_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_MEM_NATIVE_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_MEM_NATIVE_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_EVENT_NATIVE_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_EVENT_NATIVE_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_PLATFORM_NATIVE_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_PLATFORM_NATIVE_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_DEVICE_NATIVE_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_DEVICE_NATIVE_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_PROGRAM_NATIVE_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_PROGRAM_NATIVE_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_SAMPLER_NATIVE_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_SAMPLER_NATIVE_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_QUEUE_NATIVE_DESC:
+                    os << "UR_STRUCTURE_TYPE_QUEUE_NATIVE_DESC";
+                    break;
+                case UR_STRUCTURE_TYPE_DEVICE_PARTITION_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_DEVICE_PARTITION_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_KERNEL_ARG_MEM_OBJ_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_KERNEL_ARG_MEM_OBJ_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_PHYSICAL_MEM_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_PHYSICAL_MEM_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_KERNEL_ARG_POINTER_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_KERNEL_ARG_POINTER_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_KERNEL_ARG_SAMPLER_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_KERNEL_ARG_SAMPLER_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_KERNEL_EXEC_INFO_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_KERNEL_EXEC_INFO_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_KERNEL_ARG_VALUE_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_KERNEL_ARG_VALUE_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_KERNEL_ARG_LOCAL_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_KERNEL_ARG_LOCAL_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_USM_ALLOC_LOCATION_DESC:
+                    os << "UR_STRUCTURE_TYPE_USM_ALLOC_LOCATION_DESC";
+                    break;
+                case UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_DESC:
+                    os << "UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_DESC";
+                    break;
+                case UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_KERNEL_LAUNCH_DESC:
+                    os << "UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_KERNEL_LAUNCH_DESC";
+                    break;
+                case UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_MEMOBJ_ARG_DESC:
+                    os << "UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_MEMOBJ_ARG_DESC";
+                    break;
+                case UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_POINTER_ARG_DESC:
+                    os << "UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_POINTER_ARG_DESC";
+                    break;
+                case UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_VALUE_ARG_DESC:
+                    os << "UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_VALUE_ARG_DESC";
+                    break;
+                case UR_STRUCTURE_TYPE_EXP_SAMPLER_MIP_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_EXP_SAMPLER_MIP_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_EXP_EXTERNAL_MEM_DESC:
+                    os << "UR_STRUCTURE_TYPE_EXP_EXTERNAL_MEM_DESC";
+                    break;
+                case UR_STRUCTURE_TYPE_EXP_EXTERNAL_SEMAPHORE_DESC:
+                    os << "UR_STRUCTURE_TYPE_EXP_EXTERNAL_SEMAPHORE_DESC";
+                    break;
+                case UR_STRUCTURE_TYPE_EXP_FILE_DESCRIPTOR:
+                    os << "UR_STRUCTURE_TYPE_EXP_FILE_DESCRIPTOR";
+                    break;
+                case UR_STRUCTURE_TYPE_EXP_WIN32_HANDLE:
+                    os << "UR_STRUCTURE_TYPE_EXP_WIN32_HANDLE";
+                    break;
+                case UR_STRUCTURE_TYPE_EXP_SAMPLER_ADDR_MODES:
+                    os << "UR_STRUCTURE_TYPE_EXP_SAMPLER_ADDR_MODES";
+                    break;
+                case UR_STRUCTURE_TYPE_EXP_SAMPLER_CUBEMAP_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_EXP_SAMPLER_CUBEMAP_PROPERTIES";
+                    break;
+                case UR_STRUCTURE_TYPE_EXP_IMAGE_COPY_REGION:
+                    os << "UR_STRUCTURE_TYPE_EXP_IMAGE_COPY_REGION";
+                    break;
+                case UR_STRUCTURE_TYPE_EXP_ENQUEUE_NATIVE_COMMAND_PROPERTIES:
+                    os << "UR_STRUCTURE_TYPE_EXP_ENQUEUE_NATIVE_COMMAND_PROPERTIES";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_structure_type_t struct
+    inline ur_result_t printStruct(std::ostream &os, const void *ptr) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        const enum ur_structure_type_t *value = (const enum ur_structure_type_t *)ptr;
+        switch (*value) {
+                
+                case UR_STRUCTURE_TYPE_CONTEXT_PROPERTIES: {
+                    const ur_context_properties_t *pstruct = (const ur_context_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_IMAGE_DESC: {
+                    const ur_image_desc_t *pstruct = (const ur_image_desc_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_BUFFER_PROPERTIES: {
+                    const ur_buffer_properties_t *pstruct = (const ur_buffer_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_BUFFER_REGION: {
+                    const ur_buffer_region_t *pstruct = (const ur_buffer_region_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_BUFFER_CHANNEL_PROPERTIES: {
+                    const ur_buffer_channel_properties_t *pstruct = (const ur_buffer_channel_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_BUFFER_ALLOC_LOCATION_PROPERTIES: {
+                    const ur_buffer_alloc_location_properties_t *pstruct = (const ur_buffer_alloc_location_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES: {
+                    const ur_program_properties_t *pstruct = (const ur_program_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_USM_DESC: {
+                    const ur_usm_desc_t *pstruct = (const ur_usm_desc_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_USM_HOST_DESC: {
+                    const ur_usm_host_desc_t *pstruct = (const ur_usm_host_desc_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_USM_DEVICE_DESC: {
+                    const ur_usm_device_desc_t *pstruct = (const ur_usm_device_desc_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_USM_POOL_DESC: {
+                    const ur_usm_pool_desc_t *pstruct = (const ur_usm_pool_desc_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_USM_POOL_LIMITS_DESC: {
+                    const ur_usm_pool_limits_desc_t *pstruct = (const ur_usm_pool_limits_desc_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_DEVICE_BINARY: {
+                    const ur_device_binary_t *pstruct = (const ur_device_binary_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_SAMPLER_DESC: {
+                    const ur_sampler_desc_t *pstruct = (const ur_sampler_desc_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_QUEUE_PROPERTIES: {
+                    const ur_queue_properties_t *pstruct = (const ur_queue_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_QUEUE_INDEX_PROPERTIES: {
+                    const ur_queue_index_properties_t *pstruct = (const ur_queue_index_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_CONTEXT_NATIVE_PROPERTIES: {
+                    const ur_context_native_properties_t *pstruct = (const ur_context_native_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_KERNEL_NATIVE_PROPERTIES: {
+                    const ur_kernel_native_properties_t *pstruct = (const ur_kernel_native_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_QUEUE_NATIVE_PROPERTIES: {
+                    const ur_queue_native_properties_t *pstruct = (const ur_queue_native_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_MEM_NATIVE_PROPERTIES: {
+                    const ur_mem_native_properties_t *pstruct = (const ur_mem_native_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_EVENT_NATIVE_PROPERTIES: {
+                    const ur_event_native_properties_t *pstruct = (const ur_event_native_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_PLATFORM_NATIVE_PROPERTIES: {
+                    const ur_platform_native_properties_t *pstruct = (const ur_platform_native_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_DEVICE_NATIVE_PROPERTIES: {
+                    const ur_device_native_properties_t *pstruct = (const ur_device_native_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_PROGRAM_NATIVE_PROPERTIES: {
+                    const ur_program_native_properties_t *pstruct = (const ur_program_native_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_SAMPLER_NATIVE_PROPERTIES: {
+                    const ur_sampler_native_properties_t *pstruct = (const ur_sampler_native_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_QUEUE_NATIVE_DESC: {
+                    const ur_queue_native_desc_t *pstruct = (const ur_queue_native_desc_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_DEVICE_PARTITION_PROPERTIES: {
+                    const ur_device_partition_properties_t *pstruct = (const ur_device_partition_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_KERNEL_ARG_MEM_OBJ_PROPERTIES: {
+                    const ur_kernel_arg_mem_obj_properties_t *pstruct = (const ur_kernel_arg_mem_obj_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_PHYSICAL_MEM_PROPERTIES: {
+                    const ur_physical_mem_properties_t *pstruct = (const ur_physical_mem_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_KERNEL_ARG_POINTER_PROPERTIES: {
+                    const ur_kernel_arg_pointer_properties_t *pstruct = (const ur_kernel_arg_pointer_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_KERNEL_ARG_SAMPLER_PROPERTIES: {
+                    const ur_kernel_arg_sampler_properties_t *pstruct = (const ur_kernel_arg_sampler_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_KERNEL_EXEC_INFO_PROPERTIES: {
+                    const ur_kernel_exec_info_properties_t *pstruct = (const ur_kernel_exec_info_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_KERNEL_ARG_VALUE_PROPERTIES: {
+                    const ur_kernel_arg_value_properties_t *pstruct = (const ur_kernel_arg_value_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_KERNEL_ARG_LOCAL_PROPERTIES: {
+                    const ur_kernel_arg_local_properties_t *pstruct = (const ur_kernel_arg_local_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_USM_ALLOC_LOCATION_DESC: {
+                    const ur_usm_alloc_location_desc_t *pstruct = (const ur_usm_alloc_location_desc_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_DESC: {
+                    const ur_exp_command_buffer_desc_t *pstruct = (const ur_exp_command_buffer_desc_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_KERNEL_LAUNCH_DESC: {
+                    const ur_exp_command_buffer_update_kernel_launch_desc_t *pstruct = (const ur_exp_command_buffer_update_kernel_launch_desc_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_MEMOBJ_ARG_DESC: {
+                    const ur_exp_command_buffer_update_memobj_arg_desc_t *pstruct = (const ur_exp_command_buffer_update_memobj_arg_desc_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_POINTER_ARG_DESC: {
+                    const ur_exp_command_buffer_update_pointer_arg_desc_t *pstruct = (const ur_exp_command_buffer_update_pointer_arg_desc_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_UPDATE_VALUE_ARG_DESC: {
+                    const ur_exp_command_buffer_update_value_arg_desc_t *pstruct = (const ur_exp_command_buffer_update_value_arg_desc_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_EXP_SAMPLER_MIP_PROPERTIES: {
+                    const ur_exp_sampler_mip_properties_t *pstruct = (const ur_exp_sampler_mip_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_EXP_EXTERNAL_MEM_DESC: {
+                    const ur_exp_external_mem_desc_t *pstruct = (const ur_exp_external_mem_desc_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_EXP_EXTERNAL_SEMAPHORE_DESC: {
+                    const ur_exp_external_semaphore_desc_t *pstruct = (const ur_exp_external_semaphore_desc_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_EXP_FILE_DESCRIPTOR: {
+                    const ur_exp_file_descriptor_t *pstruct = (const ur_exp_file_descriptor_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_EXP_WIN32_HANDLE: {
+                    const ur_exp_win32_handle_t *pstruct = (const ur_exp_win32_handle_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_EXP_SAMPLER_ADDR_MODES: {
+                    const ur_exp_sampler_addr_modes_t *pstruct = (const ur_exp_sampler_addr_modes_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_EXP_SAMPLER_CUBEMAP_PROPERTIES: {
+                    const ur_exp_sampler_cubemap_properties_t *pstruct = (const ur_exp_sampler_cubemap_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_EXP_IMAGE_COPY_REGION: {
+                    const ur_exp_image_copy_region_t *pstruct = (const ur_exp_image_copy_region_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                
+                case UR_STRUCTURE_TYPE_EXP_ENQUEUE_NATIVE_COMMAND_PROPERTIES: {
+                    const ur_exp_enqueue_native_command_properties_t *pstruct = (const ur_exp_enqueue_native_command_properties_t *)ptr;
+                    printPtr(os, pstruct);
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_result_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_result_t value) {
+        switch (value) {
+                case UR_RESULT_SUCCESS:
+                    os << "UR_RESULT_SUCCESS";
+                    break;
+                case UR_RESULT_ERROR_INVALID_OPERATION:
+                    os << "UR_RESULT_ERROR_INVALID_OPERATION";
+                    break;
+                case UR_RESULT_ERROR_INVALID_QUEUE_PROPERTIES:
+                    os << "UR_RESULT_ERROR_INVALID_QUEUE_PROPERTIES";
+                    break;
+                case UR_RESULT_ERROR_INVALID_QUEUE:
+                    os << "UR_RESULT_ERROR_INVALID_QUEUE";
+                    break;
+                case UR_RESULT_ERROR_INVALID_VALUE:
+                    os << "UR_RESULT_ERROR_INVALID_VALUE";
+                    break;
+                case UR_RESULT_ERROR_INVALID_CONTEXT:
+                    os << "UR_RESULT_ERROR_INVALID_CONTEXT";
+                    break;
+                case UR_RESULT_ERROR_INVALID_PLATFORM:
+                    os << "UR_RESULT_ERROR_INVALID_PLATFORM";
+                    break;
+                case UR_RESULT_ERROR_INVALID_BINARY:
+                    os << "UR_RESULT_ERROR_INVALID_BINARY";
+                    break;
+                case UR_RESULT_ERROR_INVALID_PROGRAM:
+                    os << "UR_RESULT_ERROR_INVALID_PROGRAM";
+                    break;
+                case UR_RESULT_ERROR_INVALID_SAMPLER:
+                    os << "UR_RESULT_ERROR_INVALID_SAMPLER";
+                    break;
+                case UR_RESULT_ERROR_INVALID_BUFFER_SIZE:
+                    os << "UR_RESULT_ERROR_INVALID_BUFFER_SIZE";
+                    break;
+                case UR_RESULT_ERROR_INVALID_MEM_OBJECT:
+                    os << "UR_RESULT_ERROR_INVALID_MEM_OBJECT";
+                    break;
+                case UR_RESULT_ERROR_INVALID_EVENT:
+                    os << "UR_RESULT_ERROR_INVALID_EVENT";
+                    break;
+                case UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST:
+                    os << "UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST";
+                    break;
+                case UR_RESULT_ERROR_MISALIGNED_SUB_BUFFER_OFFSET:
+                    os << "UR_RESULT_ERROR_MISALIGNED_SUB_BUFFER_OFFSET";
+                    break;
+                case UR_RESULT_ERROR_INVALID_WORK_GROUP_SIZE:
+                    os << "UR_RESULT_ERROR_INVALID_WORK_GROUP_SIZE";
+                    break;
+                case UR_RESULT_ERROR_COMPILER_NOT_AVAILABLE:
+                    os << "UR_RESULT_ERROR_COMPILER_NOT_AVAILABLE";
+                    break;
+                case UR_RESULT_ERROR_PROFILING_INFO_NOT_AVAILABLE:
+                    os << "UR_RESULT_ERROR_PROFILING_INFO_NOT_AVAILABLE";
+                    break;
+                case UR_RESULT_ERROR_DEVICE_NOT_FOUND:
+                    os << "UR_RESULT_ERROR_DEVICE_NOT_FOUND";
+                    break;
+                case UR_RESULT_ERROR_INVALID_DEVICE:
+                    os << "UR_RESULT_ERROR_INVALID_DEVICE";
+                    break;
+                case UR_RESULT_ERROR_DEVICE_LOST:
+                    os << "UR_RESULT_ERROR_DEVICE_LOST";
+                    break;
+                case UR_RESULT_ERROR_DEVICE_REQUIRES_RESET:
+                    os << "UR_RESULT_ERROR_DEVICE_REQUIRES_RESET";
+                    break;
+                case UR_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE:
+                    os << "UR_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE";
+                    break;
+                case UR_RESULT_ERROR_DEVICE_PARTITION_FAILED:
+                    os << "UR_RESULT_ERROR_DEVICE_PARTITION_FAILED";
+                    break;
+                case UR_RESULT_ERROR_INVALID_DEVICE_PARTITION_COUNT:
+                    os << "UR_RESULT_ERROR_INVALID_DEVICE_PARTITION_COUNT";
+                    break;
+                case UR_RESULT_ERROR_INVALID_WORK_ITEM_SIZE:
+                    os << "UR_RESULT_ERROR_INVALID_WORK_ITEM_SIZE";
+                    break;
+                case UR_RESULT_ERROR_INVALID_WORK_DIMENSION:
+                    os << "UR_RESULT_ERROR_INVALID_WORK_DIMENSION";
+                    break;
+                case UR_RESULT_ERROR_INVALID_KERNEL_ARGS:
+                    os << "UR_RESULT_ERROR_INVALID_KERNEL_ARGS";
+                    break;
+                case UR_RESULT_ERROR_INVALID_KERNEL:
+                    os << "UR_RESULT_ERROR_INVALID_KERNEL";
+                    break;
+                case UR_RESULT_ERROR_INVALID_KERNEL_NAME:
+                    os << "UR_RESULT_ERROR_INVALID_KERNEL_NAME";
+                    break;
+                case UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_INDEX:
+                    os << "UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_INDEX";
+                    break;
+                case UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_SIZE:
+                    os << "UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_SIZE";
+                    break;
+                case UR_RESULT_ERROR_INVALID_KERNEL_ATTRIBUTE_VALUE:
+                    os << "UR_RESULT_ERROR_INVALID_KERNEL_ATTRIBUTE_VALUE";
+                    break;
+                case UR_RESULT_ERROR_INVALID_IMAGE_SIZE:
+                    os << "UR_RESULT_ERROR_INVALID_IMAGE_SIZE";
+                    break;
+                case UR_RESULT_ERROR_INVALID_IMAGE_FORMAT_DESCRIPTOR:
+                    os << "UR_RESULT_ERROR_INVALID_IMAGE_FORMAT_DESCRIPTOR";
+                    break;
+                case UR_RESULT_ERROR_MEM_OBJECT_ALLOCATION_FAILURE:
+                    os << "UR_RESULT_ERROR_MEM_OBJECT_ALLOCATION_FAILURE";
+                    break;
+                case UR_RESULT_ERROR_INVALID_PROGRAM_EXECUTABLE:
+                    os << "UR_RESULT_ERROR_INVALID_PROGRAM_EXECUTABLE";
+                    break;
+                case UR_RESULT_ERROR_UNINITIALIZED:
+                    os << "UR_RESULT_ERROR_UNINITIALIZED";
+                    break;
+                case UR_RESULT_ERROR_OUT_OF_HOST_MEMORY:
+                    os << "UR_RESULT_ERROR_OUT_OF_HOST_MEMORY";
+                    break;
+                case UR_RESULT_ERROR_OUT_OF_DEVICE_MEMORY:
+                    os << "UR_RESULT_ERROR_OUT_OF_DEVICE_MEMORY";
+                    break;
+                case UR_RESULT_ERROR_OUT_OF_RESOURCES:
+                    os << "UR_RESULT_ERROR_OUT_OF_RESOURCES";
+                    break;
+                case UR_RESULT_ERROR_PROGRAM_BUILD_FAILURE:
+                    os << "UR_RESULT_ERROR_PROGRAM_BUILD_FAILURE";
+                    break;
+                case UR_RESULT_ERROR_PROGRAM_LINK_FAILURE:
+                    os << "UR_RESULT_ERROR_PROGRAM_LINK_FAILURE";
+                    break;
+                case UR_RESULT_ERROR_UNSUPPORTED_VERSION:
+                    os << "UR_RESULT_ERROR_UNSUPPORTED_VERSION";
+                    break;
+                case UR_RESULT_ERROR_UNSUPPORTED_FEATURE:
+                    os << "UR_RESULT_ERROR_UNSUPPORTED_FEATURE";
+                    break;
+                case UR_RESULT_ERROR_INVALID_ARGUMENT:
+                    os << "UR_RESULT_ERROR_INVALID_ARGUMENT";
+                    break;
+                case UR_RESULT_ERROR_INVALID_NULL_HANDLE:
+                    os << "UR_RESULT_ERROR_INVALID_NULL_HANDLE";
+                    break;
+                case UR_RESULT_ERROR_HANDLE_OBJECT_IN_USE:
+                    os << "UR_RESULT_ERROR_HANDLE_OBJECT_IN_USE";
+                    break;
+                case UR_RESULT_ERROR_INVALID_NULL_POINTER:
+                    os << "UR_RESULT_ERROR_INVALID_NULL_POINTER";
+                    break;
+                case UR_RESULT_ERROR_INVALID_SIZE:
+                    os << "UR_RESULT_ERROR_INVALID_SIZE";
+                    break;
+                case UR_RESULT_ERROR_UNSUPPORTED_SIZE:
+                    os << "UR_RESULT_ERROR_UNSUPPORTED_SIZE";
+                    break;
+                case UR_RESULT_ERROR_UNSUPPORTED_ALIGNMENT:
+                    os << "UR_RESULT_ERROR_UNSUPPORTED_ALIGNMENT";
+                    break;
+                case UR_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT:
+                    os << "UR_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT";
+                    break;
+                case UR_RESULT_ERROR_INVALID_ENUMERATION:
+                    os << "UR_RESULT_ERROR_INVALID_ENUMERATION";
+                    break;
+                case UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION:
+                    os << "UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION";
+                    break;
+                case UR_RESULT_ERROR_UNSUPPORTED_IMAGE_FORMAT:
+                    os << "UR_RESULT_ERROR_UNSUPPORTED_IMAGE_FORMAT";
+                    break;
+                case UR_RESULT_ERROR_INVALID_NATIVE_BINARY:
+                    os << "UR_RESULT_ERROR_INVALID_NATIVE_BINARY";
+                    break;
+                case UR_RESULT_ERROR_INVALID_GLOBAL_NAME:
+                    os << "UR_RESULT_ERROR_INVALID_GLOBAL_NAME";
+                    break;
+                case UR_RESULT_ERROR_FUNCTION_ADDRESS_NOT_AVAILABLE:
+                    os << "UR_RESULT_ERROR_FUNCTION_ADDRESS_NOT_AVAILABLE";
+                    break;
+                case UR_RESULT_ERROR_INVALID_GROUP_SIZE_DIMENSION:
+                    os << "UR_RESULT_ERROR_INVALID_GROUP_SIZE_DIMENSION";
+                    break;
+                case UR_RESULT_ERROR_INVALID_GLOBAL_WIDTH_DIMENSION:
+                    os << "UR_RESULT_ERROR_INVALID_GLOBAL_WIDTH_DIMENSION";
+                    break;
+                case UR_RESULT_ERROR_PROGRAM_UNLINKED:
+                    os << "UR_RESULT_ERROR_PROGRAM_UNLINKED";
+                    break;
+                case UR_RESULT_ERROR_OVERLAPPING_REGIONS:
+                    os << "UR_RESULT_ERROR_OVERLAPPING_REGIONS";
+                    break;
+                case UR_RESULT_ERROR_INVALID_HOST_PTR:
+                    os << "UR_RESULT_ERROR_INVALID_HOST_PTR";
+                    break;
+                case UR_RESULT_ERROR_INVALID_USM_SIZE:
+                    os << "UR_RESULT_ERROR_INVALID_USM_SIZE";
+                    break;
+                case UR_RESULT_ERROR_OBJECT_ALLOCATION_FAILURE:
+                    os << "UR_RESULT_ERROR_OBJECT_ALLOCATION_FAILURE";
+                    break;
+                case UR_RESULT_ERROR_ADAPTER_SPECIFIC:
+                    os << "UR_RESULT_ERROR_ADAPTER_SPECIFIC";
+                    break;
+                case UR_RESULT_ERROR_LAYER_NOT_PRESENT:
+                    os << "UR_RESULT_ERROR_LAYER_NOT_PRESENT";
+                    break;
+                case UR_RESULT_ERROR_IN_EVENT_LIST_EXEC_STATUS:
+                    os << "UR_RESULT_ERROR_IN_EVENT_LIST_EXEC_STATUS";
+                    break;
+                case UR_RESULT_ERROR_DEVICE_NOT_AVAILABLE:
+                    os << "UR_RESULT_ERROR_DEVICE_NOT_AVAILABLE";
+                    break;
+                case UR_RESULT_ERROR_INVALID_SPEC_ID:
+                    os << "UR_RESULT_ERROR_INVALID_SPEC_ID";
+                    break;
+                case UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_EXP:
+                    os << "UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_EXP";
+                    break;
+                case UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_SYNC_POINT_EXP:
+                    os << "UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_SYNC_POINT_EXP";
+                    break;
+                case UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_SYNC_POINT_WAIT_LIST_EXP:
+                    os << "UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_SYNC_POINT_WAIT_LIST_EXP";
+                    break;
+                case UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_COMMAND_HANDLE_EXP:
+                    os << "UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_COMMAND_HANDLE_EXP";
+                    break;
+                case UR_RESULT_ERROR_UNKNOWN:
+                    os << "UR_RESULT_ERROR_UNKNOWN";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_event_wait_params_t type
+/// @brief Print operator for the ur_base_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_event_wait_params_t *params) {
-
-    os << ".numEvents = ";
-
-    os << *(params->pnumEvents);
+inline std::ostream &operator<<(std::ostream &os, const struct ur_base_properties_t params) {
+    os << "(struct ur_base_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEvents; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
     os << "}";
-
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_event_retain_params_t type
+/// @brief Print operator for the ur_base_desc_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_event_retain_params_t *params) {
-
-    os << ".hEvent = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_base_desc_t params) {
+    os << "(struct ur_base_desc_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phEvent));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_event_release_params_t type
+/// @brief Print operator for the ur_rect_offset_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_event_release_params_t *params) {
-
-    os << ".hEvent = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_rect_offset_t params) {
+    os << "(struct ur_rect_offset_t){";
+    
+        
+    
+        os << ".x = ";
+        
+        os << 
+            (params.x)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".y = ";
+        
+        os << 
+            (params.y)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".z = ";
+        
+        os << 
+            (params.z)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->phEvent));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_event_get_native_handle_params_t type
+/// @brief Print operator for the ur_rect_region_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_event_get_native_handle_params_t *params) {
-
-    os << ".hEvent = ";
-
-    ur::details::printPtr(os,
-                          *(params->phEvent));
-
-    os << ", ";
-    os << ".phNativeEvent = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_rect_region_t params) {
+    os << "(struct ur_rect_region_t){";
+    
+        
+    
+        os << ".width = ";
+        
+        os << 
+            (params.width)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".height = ";
+        
+        os << 
+            (params.height)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".depth = ";
+        
+        os << 
+            (params.depth)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->pphNativeEvent));
 
+    os << "}";
     return os;
 }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_device_init_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_init_flag_t value) {
+        switch (value) {
+                case UR_DEVICE_INIT_FLAG_GPU:
+                    os << "UR_DEVICE_INIT_FLAG_GPU";
+                    break;
+                case UR_DEVICE_INIT_FLAG_CPU:
+                    os << "UR_DEVICE_INIT_FLAG_CPU";
+                    break;
+                case UR_DEVICE_INIT_FLAG_FPGA:
+                    os << "UR_DEVICE_INIT_FLAG_FPGA";
+                    break;
+                case UR_DEVICE_INIT_FLAG_MCA:
+                    os << "UR_DEVICE_INIT_FLAG_MCA";
+                    break;
+                case UR_DEVICE_INIT_FLAG_VPU:
+                    os << "UR_DEVICE_INIT_FLAG_VPU";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_device_init_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_device_init_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_DEVICE_INIT_FLAG_GPU) == (uint32_t)UR_DEVICE_INIT_FLAG_GPU) {
+                val ^= (uint32_t)UR_DEVICE_INIT_FLAG_GPU;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_INIT_FLAG_GPU;
+            }
+            
+            if ((val & UR_DEVICE_INIT_FLAG_CPU) == (uint32_t)UR_DEVICE_INIT_FLAG_CPU) {
+                val ^= (uint32_t)UR_DEVICE_INIT_FLAG_CPU;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_INIT_FLAG_CPU;
+            }
+            
+            if ((val & UR_DEVICE_INIT_FLAG_FPGA) == (uint32_t)UR_DEVICE_INIT_FLAG_FPGA) {
+                val ^= (uint32_t)UR_DEVICE_INIT_FLAG_FPGA;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_INIT_FLAG_FPGA;
+            }
+            
+            if ((val & UR_DEVICE_INIT_FLAG_MCA) == (uint32_t)UR_DEVICE_INIT_FLAG_MCA) {
+                val ^= (uint32_t)UR_DEVICE_INIT_FLAG_MCA;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_INIT_FLAG_MCA;
+            }
+            
+            if ((val & UR_DEVICE_INIT_FLAG_VPU) == (uint32_t)UR_DEVICE_INIT_FLAG_VPU) {
+                val ^= (uint32_t)UR_DEVICE_INIT_FLAG_VPU;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_INIT_FLAG_VPU;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_loader_config_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_loader_config_info_t value) {
+        switch (value) {
+                case UR_LOADER_CONFIG_INFO_AVAILABLE_LAYERS:
+                    os << "UR_LOADER_CONFIG_INFO_AVAILABLE_LAYERS";
+                    break;
+                case UR_LOADER_CONFIG_INFO_REFERENCE_COUNT:
+                    os << "UR_LOADER_CONFIG_INFO_REFERENCE_COUNT";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_loader_config_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_loader_config_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_LOADER_CONFIG_INFO_AVAILABLE_LAYERS: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_LOADER_CONFIG_INFO_REFERENCE_COUNT: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_event_create_with_native_handle_params_t type
+/// @brief Print operator for the ur_code_location_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_event_create_with_native_handle_params_t *params) {
-
-    os << ".hNativeEvent = ";
-
-    ur::details::printPtr(os, reinterpret_cast<void *>(
-                                  *(params->phNativeEvent)));
-
-    os << ", ";
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".pProperties = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
-
-    os << ", ";
-    os << ".phEvent = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_code_location_t params) {
+    os << "(struct ur_code_location_t){";
+    
+        
+    
+        os << ".functionName = ";
+        
+        ur::details::printPtr(os, 
+            (params.functionName)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".sourceFile = ";
+        
+        ur::details::printPtr(os, 
+            (params.sourceFile)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".lineNumber = ";
+        
+        os << 
+            (params.lineNumber)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".columnNumber = ";
+        
+        os << 
+            (params.columnNumber)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
+    os << "}";
     return os;
 }
-
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_adapter_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_adapter_info_t value) {
+        switch (value) {
+                case UR_ADAPTER_INFO_BACKEND:
+                    os << "UR_ADAPTER_INFO_BACKEND";
+                    break;
+                case UR_ADAPTER_INFO_REFERENCE_COUNT:
+                    os << "UR_ADAPTER_INFO_REFERENCE_COUNT";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_adapter_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_adapter_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_ADAPTER_INFO_BACKEND: {
+                    const ur_adapter_backend_t *tptr = (const ur_adapter_backend_t *)ptr;
+                    if (sizeof(ur_adapter_backend_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_adapter_backend_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_ADAPTER_INFO_REFERENCE_COUNT: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_adapter_backend_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_adapter_backend_t value) {
+        switch (value) {
+                case UR_ADAPTER_BACKEND_UNKNOWN:
+                    os << "UR_ADAPTER_BACKEND_UNKNOWN";
+                    break;
+                case UR_ADAPTER_BACKEND_LEVEL_ZERO:
+                    os << "UR_ADAPTER_BACKEND_LEVEL_ZERO";
+                    break;
+                case UR_ADAPTER_BACKEND_OPENCL:
+                    os << "UR_ADAPTER_BACKEND_OPENCL";
+                    break;
+                case UR_ADAPTER_BACKEND_CUDA:
+                    os << "UR_ADAPTER_BACKEND_CUDA";
+                    break;
+                case UR_ADAPTER_BACKEND_HIP:
+                    os << "UR_ADAPTER_BACKEND_HIP";
+                    break;
+                case UR_ADAPTER_BACKEND_NATIVE_CPU:
+                    os << "UR_ADAPTER_BACKEND_NATIVE_CPU";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_platform_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_platform_info_t value) {
+        switch (value) {
+                case UR_PLATFORM_INFO_NAME:
+                    os << "UR_PLATFORM_INFO_NAME";
+                    break;
+                case UR_PLATFORM_INFO_VENDOR_NAME:
+                    os << "UR_PLATFORM_INFO_VENDOR_NAME";
+                    break;
+                case UR_PLATFORM_INFO_VERSION:
+                    os << "UR_PLATFORM_INFO_VERSION";
+                    break;
+                case UR_PLATFORM_INFO_EXTENSIONS:
+                    os << "UR_PLATFORM_INFO_EXTENSIONS";
+                    break;
+                case UR_PLATFORM_INFO_PROFILE:
+                    os << "UR_PLATFORM_INFO_PROFILE";
+                    break;
+                case UR_PLATFORM_INFO_BACKEND:
+                    os << "UR_PLATFORM_INFO_BACKEND";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_platform_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_platform_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_PLATFORM_INFO_NAME: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_PLATFORM_INFO_VENDOR_NAME: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_PLATFORM_INFO_VERSION: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_PLATFORM_INFO_EXTENSIONS: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_PLATFORM_INFO_PROFILE: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_PLATFORM_INFO_BACKEND: {
+                    const ur_platform_backend_t *tptr = (const ur_platform_backend_t *)ptr;
+                    if (sizeof(ur_platform_backend_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_platform_backend_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_api_version_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_api_version_t value) {
+        os << UR_MAJOR_VERSION(value) << "." << UR_MINOR_VERSION(value);
+        return os;
+    }
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_event_set_callback_params_t type
+/// @brief Print operator for the ur_platform_native_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_event_set_callback_params_t *params) {
-
-    os << ".hEvent = ";
-
-    ur::details::printPtr(os,
-                          *(params->phEvent));
-
-    os << ", ";
-    os << ".execStatus = ";
-
-    os << *(params->pexecStatus);
-
-    os << ", ";
-    os << ".pfnNotify = ";
-
-    os << reinterpret_cast<void *>(
-        *(params->ppfnNotify));
-
-    os << ", ";
-    os << ".pUserData = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_platform_native_properties_t params) {
+    os << "(struct ur_platform_native_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".isNativeHandleOwned = ";
+        
+        os << 
+            (params.isNativeHandleOwned)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->ppUserData));
 
+    os << "}";
     return os;
 }
-
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_platform_backend_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_platform_backend_t value) {
+        switch (value) {
+                case UR_PLATFORM_BACKEND_UNKNOWN:
+                    os << "UR_PLATFORM_BACKEND_UNKNOWN";
+                    break;
+                case UR_PLATFORM_BACKEND_LEVEL_ZERO:
+                    os << "UR_PLATFORM_BACKEND_LEVEL_ZERO";
+                    break;
+                case UR_PLATFORM_BACKEND_OPENCL:
+                    os << "UR_PLATFORM_BACKEND_OPENCL";
+                    break;
+                case UR_PLATFORM_BACKEND_CUDA:
+                    os << "UR_PLATFORM_BACKEND_CUDA";
+                    break;
+                case UR_PLATFORM_BACKEND_HIP:
+                    os << "UR_PLATFORM_BACKEND_HIP";
+                    break;
+                case UR_PLATFORM_BACKEND_NATIVE_CPU:
+                    os << "UR_PLATFORM_BACKEND_NATIVE_CPU";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_create_with_il_params_t type
+/// @brief Print operator for the ur_device_binary_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_create_with_il_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, const struct ur_device_binary_t params) {
+    os << "(struct ur_device_binary_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pDeviceTargetSpec = ";
+        
+        ur::details::printPtr(os, 
+            (params.pDeviceTargetSpec)
+        );
 
-    os << ".hContext = ";
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
+    os << "}";
+    return os;
+}
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_device_type_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_type_t value) {
+        switch (value) {
+                case UR_DEVICE_TYPE_DEFAULT:
+                    os << "UR_DEVICE_TYPE_DEFAULT";
+                    break;
+                case UR_DEVICE_TYPE_ALL:
+                    os << "UR_DEVICE_TYPE_ALL";
+                    break;
+                case UR_DEVICE_TYPE_GPU:
+                    os << "UR_DEVICE_TYPE_GPU";
+                    break;
+                case UR_DEVICE_TYPE_CPU:
+                    os << "UR_DEVICE_TYPE_CPU";
+                    break;
+                case UR_DEVICE_TYPE_FPGA:
+                    os << "UR_DEVICE_TYPE_FPGA";
+                    break;
+                case UR_DEVICE_TYPE_MCA:
+                    os << "UR_DEVICE_TYPE_MCA";
+                    break;
+                case UR_DEVICE_TYPE_VPU:
+                    os << "UR_DEVICE_TYPE_VPU";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_device_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_info_t value) {
+        switch (value) {
+                case UR_DEVICE_INFO_TYPE:
+                    os << "UR_DEVICE_INFO_TYPE";
+                    break;
+                case UR_DEVICE_INFO_VENDOR_ID:
+                    os << "UR_DEVICE_INFO_VENDOR_ID";
+                    break;
+                case UR_DEVICE_INFO_DEVICE_ID:
+                    os << "UR_DEVICE_INFO_DEVICE_ID";
+                    break;
+                case UR_DEVICE_INFO_MAX_COMPUTE_UNITS:
+                    os << "UR_DEVICE_INFO_MAX_COMPUTE_UNITS";
+                    break;
+                case UR_DEVICE_INFO_MAX_WORK_ITEM_DIMENSIONS:
+                    os << "UR_DEVICE_INFO_MAX_WORK_ITEM_DIMENSIONS";
+                    break;
+                case UR_DEVICE_INFO_MAX_WORK_ITEM_SIZES:
+                    os << "UR_DEVICE_INFO_MAX_WORK_ITEM_SIZES";
+                    break;
+                case UR_DEVICE_INFO_MAX_WORK_GROUP_SIZE:
+                    os << "UR_DEVICE_INFO_MAX_WORK_GROUP_SIZE";
+                    break;
+                case UR_DEVICE_INFO_SINGLE_FP_CONFIG:
+                    os << "UR_DEVICE_INFO_SINGLE_FP_CONFIG";
+                    break;
+                case UR_DEVICE_INFO_HALF_FP_CONFIG:
+                    os << "UR_DEVICE_INFO_HALF_FP_CONFIG";
+                    break;
+                case UR_DEVICE_INFO_DOUBLE_FP_CONFIG:
+                    os << "UR_DEVICE_INFO_DOUBLE_FP_CONFIG";
+                    break;
+                case UR_DEVICE_INFO_QUEUE_PROPERTIES:
+                    os << "UR_DEVICE_INFO_QUEUE_PROPERTIES";
+                    break;
+                case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_CHAR:
+                    os << "UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_CHAR";
+                    break;
+                case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_SHORT:
+                    os << "UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_SHORT";
+                    break;
+                case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_INT:
+                    os << "UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_INT";
+                    break;
+                case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_LONG:
+                    os << "UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_LONG";
+                    break;
+                case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_FLOAT:
+                    os << "UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_FLOAT";
+                    break;
+                case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_DOUBLE:
+                    os << "UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_DOUBLE";
+                    break;
+                case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_HALF:
+                    os << "UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_HALF";
+                    break;
+                case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_CHAR:
+                    os << "UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_CHAR";
+                    break;
+                case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_SHORT:
+                    os << "UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_SHORT";
+                    break;
+                case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_INT:
+                    os << "UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_INT";
+                    break;
+                case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_LONG:
+                    os << "UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_LONG";
+                    break;
+                case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_FLOAT:
+                    os << "UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_FLOAT";
+                    break;
+                case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_DOUBLE:
+                    os << "UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_DOUBLE";
+                    break;
+                case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF:
+                    os << "UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF";
+                    break;
+                case UR_DEVICE_INFO_MAX_CLOCK_FREQUENCY:
+                    os << "UR_DEVICE_INFO_MAX_CLOCK_FREQUENCY";
+                    break;
+                case UR_DEVICE_INFO_MEMORY_CLOCK_RATE:
+                    os << "UR_DEVICE_INFO_MEMORY_CLOCK_RATE";
+                    break;
+                case UR_DEVICE_INFO_ADDRESS_BITS:
+                    os << "UR_DEVICE_INFO_ADDRESS_BITS";
+                    break;
+                case UR_DEVICE_INFO_MAX_MEM_ALLOC_SIZE:
+                    os << "UR_DEVICE_INFO_MAX_MEM_ALLOC_SIZE";
+                    break;
+                case UR_DEVICE_INFO_IMAGE_SUPPORTED:
+                    os << "UR_DEVICE_INFO_IMAGE_SUPPORTED";
+                    break;
+                case UR_DEVICE_INFO_MAX_READ_IMAGE_ARGS:
+                    os << "UR_DEVICE_INFO_MAX_READ_IMAGE_ARGS";
+                    break;
+                case UR_DEVICE_INFO_MAX_WRITE_IMAGE_ARGS:
+                    os << "UR_DEVICE_INFO_MAX_WRITE_IMAGE_ARGS";
+                    break;
+                case UR_DEVICE_INFO_MAX_READ_WRITE_IMAGE_ARGS:
+                    os << "UR_DEVICE_INFO_MAX_READ_WRITE_IMAGE_ARGS";
+                    break;
+                case UR_DEVICE_INFO_IMAGE2D_MAX_WIDTH:
+                    os << "UR_DEVICE_INFO_IMAGE2D_MAX_WIDTH";
+                    break;
+                case UR_DEVICE_INFO_IMAGE2D_MAX_HEIGHT:
+                    os << "UR_DEVICE_INFO_IMAGE2D_MAX_HEIGHT";
+                    break;
+                case UR_DEVICE_INFO_IMAGE3D_MAX_WIDTH:
+                    os << "UR_DEVICE_INFO_IMAGE3D_MAX_WIDTH";
+                    break;
+                case UR_DEVICE_INFO_IMAGE3D_MAX_HEIGHT:
+                    os << "UR_DEVICE_INFO_IMAGE3D_MAX_HEIGHT";
+                    break;
+                case UR_DEVICE_INFO_IMAGE3D_MAX_DEPTH:
+                    os << "UR_DEVICE_INFO_IMAGE3D_MAX_DEPTH";
+                    break;
+                case UR_DEVICE_INFO_IMAGE_MAX_BUFFER_SIZE:
+                    os << "UR_DEVICE_INFO_IMAGE_MAX_BUFFER_SIZE";
+                    break;
+                case UR_DEVICE_INFO_IMAGE_MAX_ARRAY_SIZE:
+                    os << "UR_DEVICE_INFO_IMAGE_MAX_ARRAY_SIZE";
+                    break;
+                case UR_DEVICE_INFO_MAX_SAMPLERS:
+                    os << "UR_DEVICE_INFO_MAX_SAMPLERS";
+                    break;
+                case UR_DEVICE_INFO_MAX_PARAMETER_SIZE:
+                    os << "UR_DEVICE_INFO_MAX_PARAMETER_SIZE";
+                    break;
+                case UR_DEVICE_INFO_MEM_BASE_ADDR_ALIGN:
+                    os << "UR_DEVICE_INFO_MEM_BASE_ADDR_ALIGN";
+                    break;
+                case UR_DEVICE_INFO_GLOBAL_MEM_CACHE_TYPE:
+                    os << "UR_DEVICE_INFO_GLOBAL_MEM_CACHE_TYPE";
+                    break;
+                case UR_DEVICE_INFO_GLOBAL_MEM_CACHELINE_SIZE:
+                    os << "UR_DEVICE_INFO_GLOBAL_MEM_CACHELINE_SIZE";
+                    break;
+                case UR_DEVICE_INFO_GLOBAL_MEM_CACHE_SIZE:
+                    os << "UR_DEVICE_INFO_GLOBAL_MEM_CACHE_SIZE";
+                    break;
+                case UR_DEVICE_INFO_GLOBAL_MEM_SIZE:
+                    os << "UR_DEVICE_INFO_GLOBAL_MEM_SIZE";
+                    break;
+                case UR_DEVICE_INFO_GLOBAL_MEM_FREE:
+                    os << "UR_DEVICE_INFO_GLOBAL_MEM_FREE";
+                    break;
+                case UR_DEVICE_INFO_MAX_CONSTANT_BUFFER_SIZE:
+                    os << "UR_DEVICE_INFO_MAX_CONSTANT_BUFFER_SIZE";
+                    break;
+                case UR_DEVICE_INFO_MAX_CONSTANT_ARGS:
+                    os << "UR_DEVICE_INFO_MAX_CONSTANT_ARGS";
+                    break;
+                case UR_DEVICE_INFO_LOCAL_MEM_TYPE:
+                    os << "UR_DEVICE_INFO_LOCAL_MEM_TYPE";
+                    break;
+                case UR_DEVICE_INFO_LOCAL_MEM_SIZE:
+                    os << "UR_DEVICE_INFO_LOCAL_MEM_SIZE";
+                    break;
+                case UR_DEVICE_INFO_ERROR_CORRECTION_SUPPORT:
+                    os << "UR_DEVICE_INFO_ERROR_CORRECTION_SUPPORT";
+                    break;
+                case UR_DEVICE_INFO_HOST_UNIFIED_MEMORY:
+                    os << "UR_DEVICE_INFO_HOST_UNIFIED_MEMORY";
+                    break;
+                case UR_DEVICE_INFO_PROFILING_TIMER_RESOLUTION:
+                    os << "UR_DEVICE_INFO_PROFILING_TIMER_RESOLUTION";
+                    break;
+                case UR_DEVICE_INFO_ENDIAN_LITTLE:
+                    os << "UR_DEVICE_INFO_ENDIAN_LITTLE";
+                    break;
+                case UR_DEVICE_INFO_AVAILABLE:
+                    os << "UR_DEVICE_INFO_AVAILABLE";
+                    break;
+                case UR_DEVICE_INFO_COMPILER_AVAILABLE:
+                    os << "UR_DEVICE_INFO_COMPILER_AVAILABLE";
+                    break;
+                case UR_DEVICE_INFO_LINKER_AVAILABLE:
+                    os << "UR_DEVICE_INFO_LINKER_AVAILABLE";
+                    break;
+                case UR_DEVICE_INFO_EXECUTION_CAPABILITIES:
+                    os << "UR_DEVICE_INFO_EXECUTION_CAPABILITIES";
+                    break;
+                case UR_DEVICE_INFO_QUEUE_ON_DEVICE_PROPERTIES:
+                    os << "UR_DEVICE_INFO_QUEUE_ON_DEVICE_PROPERTIES";
+                    break;
+                case UR_DEVICE_INFO_QUEUE_ON_HOST_PROPERTIES:
+                    os << "UR_DEVICE_INFO_QUEUE_ON_HOST_PROPERTIES";
+                    break;
+                case UR_DEVICE_INFO_BUILT_IN_KERNELS:
+                    os << "UR_DEVICE_INFO_BUILT_IN_KERNELS";
+                    break;
+                case UR_DEVICE_INFO_PLATFORM:
+                    os << "UR_DEVICE_INFO_PLATFORM";
+                    break;
+                case UR_DEVICE_INFO_REFERENCE_COUNT:
+                    os << "UR_DEVICE_INFO_REFERENCE_COUNT";
+                    break;
+                case UR_DEVICE_INFO_IL_VERSION:
+                    os << "UR_DEVICE_INFO_IL_VERSION";
+                    break;
+                case UR_DEVICE_INFO_NAME:
+                    os << "UR_DEVICE_INFO_NAME";
+                    break;
+                case UR_DEVICE_INFO_VENDOR:
+                    os << "UR_DEVICE_INFO_VENDOR";
+                    break;
+                case UR_DEVICE_INFO_DRIVER_VERSION:
+                    os << "UR_DEVICE_INFO_DRIVER_VERSION";
+                    break;
+                case UR_DEVICE_INFO_PROFILE:
+                    os << "UR_DEVICE_INFO_PROFILE";
+                    break;
+                case UR_DEVICE_INFO_VERSION:
+                    os << "UR_DEVICE_INFO_VERSION";
+                    break;
+                case UR_DEVICE_INFO_BACKEND_RUNTIME_VERSION:
+                    os << "UR_DEVICE_INFO_BACKEND_RUNTIME_VERSION";
+                    break;
+                case UR_DEVICE_INFO_EXTENSIONS:
+                    os << "UR_DEVICE_INFO_EXTENSIONS";
+                    break;
+                case UR_DEVICE_INFO_PRINTF_BUFFER_SIZE:
+                    os << "UR_DEVICE_INFO_PRINTF_BUFFER_SIZE";
+                    break;
+                case UR_DEVICE_INFO_PREFERRED_INTEROP_USER_SYNC:
+                    os << "UR_DEVICE_INFO_PREFERRED_INTEROP_USER_SYNC";
+                    break;
+                case UR_DEVICE_INFO_PARENT_DEVICE:
+                    os << "UR_DEVICE_INFO_PARENT_DEVICE";
+                    break;
+                case UR_DEVICE_INFO_SUPPORTED_PARTITIONS:
+                    os << "UR_DEVICE_INFO_SUPPORTED_PARTITIONS";
+                    break;
+                case UR_DEVICE_INFO_PARTITION_MAX_SUB_DEVICES:
+                    os << "UR_DEVICE_INFO_PARTITION_MAX_SUB_DEVICES";
+                    break;
+                case UR_DEVICE_INFO_PARTITION_AFFINITY_DOMAIN:
+                    os << "UR_DEVICE_INFO_PARTITION_AFFINITY_DOMAIN";
+                    break;
+                case UR_DEVICE_INFO_PARTITION_TYPE:
+                    os << "UR_DEVICE_INFO_PARTITION_TYPE";
+                    break;
+                case UR_DEVICE_INFO_MAX_NUM_SUB_GROUPS:
+                    os << "UR_DEVICE_INFO_MAX_NUM_SUB_GROUPS";
+                    break;
+                case UR_DEVICE_INFO_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS:
+                    os << "UR_DEVICE_INFO_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS";
+                    break;
+                case UR_DEVICE_INFO_SUB_GROUP_SIZES_INTEL:
+                    os << "UR_DEVICE_INFO_SUB_GROUP_SIZES_INTEL";
+                    break;
+                case UR_DEVICE_INFO_USM_HOST_SUPPORT:
+                    os << "UR_DEVICE_INFO_USM_HOST_SUPPORT";
+                    break;
+                case UR_DEVICE_INFO_USM_DEVICE_SUPPORT:
+                    os << "UR_DEVICE_INFO_USM_DEVICE_SUPPORT";
+                    break;
+                case UR_DEVICE_INFO_USM_SINGLE_SHARED_SUPPORT:
+                    os << "UR_DEVICE_INFO_USM_SINGLE_SHARED_SUPPORT";
+                    break;
+                case UR_DEVICE_INFO_USM_CROSS_SHARED_SUPPORT:
+                    os << "UR_DEVICE_INFO_USM_CROSS_SHARED_SUPPORT";
+                    break;
+                case UR_DEVICE_INFO_USM_SYSTEM_SHARED_SUPPORT:
+                    os << "UR_DEVICE_INFO_USM_SYSTEM_SHARED_SUPPORT";
+                    break;
+                case UR_DEVICE_INFO_UUID:
+                    os << "UR_DEVICE_INFO_UUID";
+                    break;
+                case UR_DEVICE_INFO_PCI_ADDRESS:
+                    os << "UR_DEVICE_INFO_PCI_ADDRESS";
+                    break;
+                case UR_DEVICE_INFO_GPU_EU_COUNT:
+                    os << "UR_DEVICE_INFO_GPU_EU_COUNT";
+                    break;
+                case UR_DEVICE_INFO_GPU_EU_SIMD_WIDTH:
+                    os << "UR_DEVICE_INFO_GPU_EU_SIMD_WIDTH";
+                    break;
+                case UR_DEVICE_INFO_GPU_EU_SLICES:
+                    os << "UR_DEVICE_INFO_GPU_EU_SLICES";
+                    break;
+                case UR_DEVICE_INFO_GPU_EU_COUNT_PER_SUBSLICE:
+                    os << "UR_DEVICE_INFO_GPU_EU_COUNT_PER_SUBSLICE";
+                    break;
+                case UR_DEVICE_INFO_GPU_SUBSLICES_PER_SLICE:
+                    os << "UR_DEVICE_INFO_GPU_SUBSLICES_PER_SLICE";
+                    break;
+                case UR_DEVICE_INFO_GPU_HW_THREADS_PER_EU:
+                    os << "UR_DEVICE_INFO_GPU_HW_THREADS_PER_EU";
+                    break;
+                case UR_DEVICE_INFO_MAX_MEMORY_BANDWIDTH:
+                    os << "UR_DEVICE_INFO_MAX_MEMORY_BANDWIDTH";
+                    break;
+                case UR_DEVICE_INFO_IMAGE_SRGB:
+                    os << "UR_DEVICE_INFO_IMAGE_SRGB";
+                    break;
+                case UR_DEVICE_INFO_BUILD_ON_SUBDEVICE:
+                    os << "UR_DEVICE_INFO_BUILD_ON_SUBDEVICE";
+                    break;
+                case UR_DEVICE_INFO_ATOMIC_64:
+                    os << "UR_DEVICE_INFO_ATOMIC_64";
+                    break;
+                case UR_DEVICE_INFO_ATOMIC_MEMORY_ORDER_CAPABILITIES:
+                    os << "UR_DEVICE_INFO_ATOMIC_MEMORY_ORDER_CAPABILITIES";
+                    break;
+                case UR_DEVICE_INFO_ATOMIC_MEMORY_SCOPE_CAPABILITIES:
+                    os << "UR_DEVICE_INFO_ATOMIC_MEMORY_SCOPE_CAPABILITIES";
+                    break;
+                case UR_DEVICE_INFO_ATOMIC_FENCE_ORDER_CAPABILITIES:
+                    os << "UR_DEVICE_INFO_ATOMIC_FENCE_ORDER_CAPABILITIES";
+                    break;
+                case UR_DEVICE_INFO_ATOMIC_FENCE_SCOPE_CAPABILITIES:
+                    os << "UR_DEVICE_INFO_ATOMIC_FENCE_SCOPE_CAPABILITIES";
+                    break;
+                case UR_DEVICE_INFO_BFLOAT16:
+                    os << "UR_DEVICE_INFO_BFLOAT16";
+                    break;
+                case UR_DEVICE_INFO_MAX_COMPUTE_QUEUE_INDICES:
+                    os << "UR_DEVICE_INFO_MAX_COMPUTE_QUEUE_INDICES";
+                    break;
+                case UR_DEVICE_INFO_KERNEL_SET_SPECIALIZATION_CONSTANTS:
+                    os << "UR_DEVICE_INFO_KERNEL_SET_SPECIALIZATION_CONSTANTS";
+                    break;
+                case UR_DEVICE_INFO_MEMORY_BUS_WIDTH:
+                    os << "UR_DEVICE_INFO_MEMORY_BUS_WIDTH";
+                    break;
+                case UR_DEVICE_INFO_MAX_WORK_GROUPS_3D:
+                    os << "UR_DEVICE_INFO_MAX_WORK_GROUPS_3D";
+                    break;
+                case UR_DEVICE_INFO_ASYNC_BARRIER:
+                    os << "UR_DEVICE_INFO_ASYNC_BARRIER";
+                    break;
+                case UR_DEVICE_INFO_MEM_CHANNEL_SUPPORT:
+                    os << "UR_DEVICE_INFO_MEM_CHANNEL_SUPPORT";
+                    break;
+                case UR_DEVICE_INFO_HOST_PIPE_READ_WRITE_SUPPORTED:
+                    os << "UR_DEVICE_INFO_HOST_PIPE_READ_WRITE_SUPPORTED";
+                    break;
+                case UR_DEVICE_INFO_MAX_REGISTERS_PER_WORK_GROUP:
+                    os << "UR_DEVICE_INFO_MAX_REGISTERS_PER_WORK_GROUP";
+                    break;
+                case UR_DEVICE_INFO_IP_VERSION:
+                    os << "UR_DEVICE_INFO_IP_VERSION";
+                    break;
+                case UR_DEVICE_INFO_VIRTUAL_MEMORY_SUPPORT:
+                    os << "UR_DEVICE_INFO_VIRTUAL_MEMORY_SUPPORT";
+                    break;
+                case UR_DEVICE_INFO_ESIMD_SUPPORT:
+                    os << "UR_DEVICE_INFO_ESIMD_SUPPORT";
+                    break;
+                case UR_DEVICE_INFO_COMPONENT_DEVICES:
+                    os << "UR_DEVICE_INFO_COMPONENT_DEVICES";
+                    break;
+                case UR_DEVICE_INFO_COMPOSITE_DEVICE:
+                    os << "UR_DEVICE_INFO_COMPOSITE_DEVICE";
+                    break;
+                case UR_DEVICE_INFO_GLOBAL_VARIABLE_SUPPORT:
+                    os << "UR_DEVICE_INFO_GLOBAL_VARIABLE_SUPPORT";
+                    break;
+                case UR_DEVICE_INFO_COMMAND_BUFFER_SUPPORT_EXP:
+                    os << "UR_DEVICE_INFO_COMMAND_BUFFER_SUPPORT_EXP";
+                    break;
+                case UR_DEVICE_INFO_COMMAND_BUFFER_UPDATE_CAPABILITIES_EXP:
+                    os << "UR_DEVICE_INFO_COMMAND_BUFFER_UPDATE_CAPABILITIES_EXP";
+                    break;
+                case UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP:
+                    os << "UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP";
+                    break;
+                case UR_DEVICE_INFO_CLUSTER_LAUNCH_EXP:
+                    os << "UR_DEVICE_INFO_CLUSTER_LAUNCH_EXP";
+                    break;
+                case UR_DEVICE_INFO_BINDLESS_IMAGES_SUPPORT_EXP:
+                    os << "UR_DEVICE_INFO_BINDLESS_IMAGES_SUPPORT_EXP";
+                    break;
+                case UR_DEVICE_INFO_BINDLESS_IMAGES_SHARED_USM_SUPPORT_EXP:
+                    os << "UR_DEVICE_INFO_BINDLESS_IMAGES_SHARED_USM_SUPPORT_EXP";
+                    break;
+                case UR_DEVICE_INFO_BINDLESS_IMAGES_1D_USM_SUPPORT_EXP:
+                    os << "UR_DEVICE_INFO_BINDLESS_IMAGES_1D_USM_SUPPORT_EXP";
+                    break;
+                case UR_DEVICE_INFO_BINDLESS_IMAGES_2D_USM_SUPPORT_EXP:
+                    os << "UR_DEVICE_INFO_BINDLESS_IMAGES_2D_USM_SUPPORT_EXP";
+                    break;
+                case UR_DEVICE_INFO_IMAGE_PITCH_ALIGN_EXP:
+                    os << "UR_DEVICE_INFO_IMAGE_PITCH_ALIGN_EXP";
+                    break;
+                case UR_DEVICE_INFO_MAX_IMAGE_LINEAR_WIDTH_EXP:
+                    os << "UR_DEVICE_INFO_MAX_IMAGE_LINEAR_WIDTH_EXP";
+                    break;
+                case UR_DEVICE_INFO_MAX_IMAGE_LINEAR_HEIGHT_EXP:
+                    os << "UR_DEVICE_INFO_MAX_IMAGE_LINEAR_HEIGHT_EXP";
+                    break;
+                case UR_DEVICE_INFO_MAX_IMAGE_LINEAR_PITCH_EXP:
+                    os << "UR_DEVICE_INFO_MAX_IMAGE_LINEAR_PITCH_EXP";
+                    break;
+                case UR_DEVICE_INFO_MIPMAP_SUPPORT_EXP:
+                    os << "UR_DEVICE_INFO_MIPMAP_SUPPORT_EXP";
+                    break;
+                case UR_DEVICE_INFO_MIPMAP_ANISOTROPY_SUPPORT_EXP:
+                    os << "UR_DEVICE_INFO_MIPMAP_ANISOTROPY_SUPPORT_EXP";
+                    break;
+                case UR_DEVICE_INFO_MIPMAP_MAX_ANISOTROPY_EXP:
+                    os << "UR_DEVICE_INFO_MIPMAP_MAX_ANISOTROPY_EXP";
+                    break;
+                case UR_DEVICE_INFO_MIPMAP_LEVEL_REFERENCE_SUPPORT_EXP:
+                    os << "UR_DEVICE_INFO_MIPMAP_LEVEL_REFERENCE_SUPPORT_EXP";
+                    break;
+                case UR_DEVICE_INFO_EXTERNAL_MEMORY_IMPORT_SUPPORT_EXP:
+                    os << "UR_DEVICE_INFO_EXTERNAL_MEMORY_IMPORT_SUPPORT_EXP";
+                    break;
+                case UR_DEVICE_INFO_EXTERNAL_SEMAPHORE_IMPORT_SUPPORT_EXP:
+                    os << "UR_DEVICE_INFO_EXTERNAL_SEMAPHORE_IMPORT_SUPPORT_EXP";
+                    break;
+                case UR_DEVICE_INFO_CUBEMAP_SUPPORT_EXP:
+                    os << "UR_DEVICE_INFO_CUBEMAP_SUPPORT_EXP";
+                    break;
+                case UR_DEVICE_INFO_CUBEMAP_SEAMLESS_FILTERING_SUPPORT_EXP:
+                    os << "UR_DEVICE_INFO_CUBEMAP_SEAMLESS_FILTERING_SUPPORT_EXP";
+                    break;
+                case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_USM_EXP:
+                    os << "UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_USM_EXP";
+                    break;
+                case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_EXP:
+                    os << "UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_EXP";
+                    break;
+                case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_USM_EXP:
+                    os << "UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_USM_EXP";
+                    break;
+                case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_EXP:
+                    os << "UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_EXP";
+                    break;
+                case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_3D_EXP:
+                    os << "UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_3D_EXP";
+                    break;
+                case UR_DEVICE_INFO_TIMESTAMP_RECORDING_SUPPORT_EXP:
+                    os << "UR_DEVICE_INFO_TIMESTAMP_RECORDING_SUPPORT_EXP";
+                    break;
+                case UR_DEVICE_INFO_IMAGE_ARRAY_SUPPORT_EXP:
+                    os << "UR_DEVICE_INFO_IMAGE_ARRAY_SUPPORT_EXP";
+                    break;
+                case UR_DEVICE_INFO_BINDLESS_UNIQUE_ADDRESSING_PER_DIM_EXP:
+                    os << "UR_DEVICE_INFO_BINDLESS_UNIQUE_ADDRESSING_PER_DIM_EXP";
+                    break;
+                case UR_DEVICE_INFO_BINDLESS_SAMPLE_1D_USM_EXP:
+                    os << "UR_DEVICE_INFO_BINDLESS_SAMPLE_1D_USM_EXP";
+                    break;
+                case UR_DEVICE_INFO_BINDLESS_SAMPLE_2D_USM_EXP:
+                    os << "UR_DEVICE_INFO_BINDLESS_SAMPLE_2D_USM_EXP";
+                    break;
+                case UR_DEVICE_INFO_ENQUEUE_NATIVE_COMMAND_SUPPORT_EXP:
+                    os << "UR_DEVICE_INFO_ENQUEUE_NATIVE_COMMAND_SUPPORT_EXP";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_device_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_device_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_DEVICE_INFO_TYPE: {
+                    const ur_device_type_t *tptr = (const ur_device_type_t *)ptr;
+                    if (sizeof(ur_device_type_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_type_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_VENDOR_ID: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_DEVICE_ID: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MAX_COMPUTE_UNITS: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MAX_WORK_ITEM_DIMENSIONS: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MAX_WORK_ITEM_SIZES: {
+                    
+                    const size_t *tptr = (const size_t *)ptr;
+                            os << "{";
+                            size_t nelems = size / sizeof(size_t);
+                            for (size_t i = 0; i < nelems; ++i) {
+                                if (i != 0) {
+                                    os << ", ";
+                                }
+                                
+        os << 
+                                    tptr[i]
+                                ;
+
+                            }
+                            os << "}";
+                } break;
+                case UR_DEVICE_INFO_MAX_WORK_GROUP_SIZE: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_SINGLE_FP_CONFIG: {
+                    const ur_device_fp_capability_flags_t *tptr = (const ur_device_fp_capability_flags_t *)ptr;
+                    if (sizeof(ur_device_fp_capability_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_fp_capability_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_device_fp_capability_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_HALF_FP_CONFIG: {
+                    const ur_device_fp_capability_flags_t *tptr = (const ur_device_fp_capability_flags_t *)ptr;
+                    if (sizeof(ur_device_fp_capability_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_fp_capability_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_device_fp_capability_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_DOUBLE_FP_CONFIG: {
+                    const ur_device_fp_capability_flags_t *tptr = (const ur_device_fp_capability_flags_t *)ptr;
+                    if (sizeof(ur_device_fp_capability_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_fp_capability_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_device_fp_capability_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_QUEUE_PROPERTIES: {
+                    const ur_queue_flags_t *tptr = (const ur_queue_flags_t *)ptr;
+                    if (sizeof(ur_queue_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_queue_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_queue_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_CHAR: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_SHORT: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_INT: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_LONG: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_FLOAT: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_DOUBLE: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_HALF: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_CHAR: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_SHORT: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_INT: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_LONG: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_FLOAT: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_DOUBLE: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MAX_CLOCK_FREQUENCY: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MEMORY_CLOCK_RATE: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_ADDRESS_BITS: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MAX_MEM_ALLOC_SIZE: {
+                    const uint64_t *tptr = (const uint64_t *)ptr;
+                    if (sizeof(uint64_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_IMAGE_SUPPORTED: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MAX_READ_IMAGE_ARGS: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MAX_WRITE_IMAGE_ARGS: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MAX_READ_WRITE_IMAGE_ARGS: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_IMAGE2D_MAX_WIDTH: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_IMAGE2D_MAX_HEIGHT: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_IMAGE3D_MAX_WIDTH: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_IMAGE3D_MAX_HEIGHT: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_IMAGE3D_MAX_DEPTH: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_IMAGE_MAX_BUFFER_SIZE: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_IMAGE_MAX_ARRAY_SIZE: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MAX_SAMPLERS: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MAX_PARAMETER_SIZE: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MEM_BASE_ADDR_ALIGN: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_GLOBAL_MEM_CACHE_TYPE: {
+                    const ur_device_mem_cache_type_t *tptr = (const ur_device_mem_cache_type_t *)ptr;
+                    if (sizeof(ur_device_mem_cache_type_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_mem_cache_type_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_GLOBAL_MEM_CACHELINE_SIZE: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_GLOBAL_MEM_CACHE_SIZE: {
+                    const uint64_t *tptr = (const uint64_t *)ptr;
+                    if (sizeof(uint64_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_GLOBAL_MEM_SIZE: {
+                    const uint64_t *tptr = (const uint64_t *)ptr;
+                    if (sizeof(uint64_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_GLOBAL_MEM_FREE: {
+                    const uint64_t *tptr = (const uint64_t *)ptr;
+                    if (sizeof(uint64_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MAX_CONSTANT_BUFFER_SIZE: {
+                    const uint64_t *tptr = (const uint64_t *)ptr;
+                    if (sizeof(uint64_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MAX_CONSTANT_ARGS: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_LOCAL_MEM_TYPE: {
+                    const ur_device_local_mem_type_t *tptr = (const ur_device_local_mem_type_t *)ptr;
+                    if (sizeof(ur_device_local_mem_type_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_local_mem_type_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_LOCAL_MEM_SIZE: {
+                    const uint64_t *tptr = (const uint64_t *)ptr;
+                    if (sizeof(uint64_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_ERROR_CORRECTION_SUPPORT: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_HOST_UNIFIED_MEMORY: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_PROFILING_TIMER_RESOLUTION: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_ENDIAN_LITTLE: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_AVAILABLE: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_COMPILER_AVAILABLE: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_LINKER_AVAILABLE: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_EXECUTION_CAPABILITIES: {
+                    const ur_device_exec_capability_flags_t *tptr = (const ur_device_exec_capability_flags_t *)ptr;
+                    if (sizeof(ur_device_exec_capability_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_exec_capability_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_device_exec_capability_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_QUEUE_ON_DEVICE_PROPERTIES: {
+                    const ur_queue_flags_t *tptr = (const ur_queue_flags_t *)ptr;
+                    if (sizeof(ur_queue_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_queue_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_queue_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_QUEUE_ON_HOST_PROPERTIES: {
+                    const ur_queue_flags_t *tptr = (const ur_queue_flags_t *)ptr;
+                    if (sizeof(ur_queue_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_queue_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_queue_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_BUILT_IN_KERNELS: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_DEVICE_INFO_PLATFORM: {
+                    const ur_platform_handle_t *tptr = (const ur_platform_handle_t *)ptr;
+                    if (sizeof(ur_platform_handle_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_platform_handle_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printPtr(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_REFERENCE_COUNT: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_IL_VERSION: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_DEVICE_INFO_NAME: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_DEVICE_INFO_VENDOR: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_DEVICE_INFO_DRIVER_VERSION: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_DEVICE_INFO_PROFILE: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_DEVICE_INFO_VERSION: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_DEVICE_INFO_BACKEND_RUNTIME_VERSION: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_DEVICE_INFO_EXTENSIONS: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_DEVICE_INFO_PRINTF_BUFFER_SIZE: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_PREFERRED_INTEROP_USER_SYNC: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_PARENT_DEVICE: {
+                    const ur_device_handle_t *tptr = (const ur_device_handle_t *)ptr;
+                    if (sizeof(ur_device_handle_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_handle_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printPtr(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_SUPPORTED_PARTITIONS: {
+                    
+                    const ur_device_partition_t *tptr = (const ur_device_partition_t *)ptr;
+                            os << "{";
+                            size_t nelems = size / sizeof(ur_device_partition_t);
+                            for (size_t i = 0; i < nelems; ++i) {
+                                if (i != 0) {
+                                    os << ", ";
+                                }
+                                
+        os << 
+                                    tptr[i]
+                                ;
+
+                            }
+                            os << "}";
+                } break;
+                case UR_DEVICE_INFO_PARTITION_MAX_SUB_DEVICES: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_PARTITION_AFFINITY_DOMAIN: {
+                    const ur_device_affinity_domain_flags_t *tptr = (const ur_device_affinity_domain_flags_t *)ptr;
+                    if (sizeof(ur_device_affinity_domain_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_affinity_domain_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_device_affinity_domain_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_PARTITION_TYPE: {
+                    
+                    const ur_device_partition_property_t *tptr = (const ur_device_partition_property_t *)ptr;
+                            os << "{";
+                            size_t nelems = size / sizeof(ur_device_partition_property_t);
+                            for (size_t i = 0; i < nelems; ++i) {
+                                if (i != 0) {
+                                    os << ", ";
+                                }
+                                
+        os << 
+                                    tptr[i]
+                                ;
+
+                            }
+                            os << "}";
+                } break;
+                case UR_DEVICE_INFO_MAX_NUM_SUB_GROUPS: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_SUB_GROUP_SIZES_INTEL: {
+                    
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                            os << "{";
+                            size_t nelems = size / sizeof(uint32_t);
+                            for (size_t i = 0; i < nelems; ++i) {
+                                if (i != 0) {
+                                    os << ", ";
+                                }
+                                
+        os << 
+                                    tptr[i]
+                                ;
+
+                            }
+                            os << "}";
+                } break;
+                case UR_DEVICE_INFO_USM_HOST_SUPPORT: {
+                    const ur_device_usm_access_capability_flags_t *tptr = (const ur_device_usm_access_capability_flags_t *)ptr;
+                    if (sizeof(ur_device_usm_access_capability_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_usm_access_capability_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_device_usm_access_capability_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_USM_DEVICE_SUPPORT: {
+                    const ur_device_usm_access_capability_flags_t *tptr = (const ur_device_usm_access_capability_flags_t *)ptr;
+                    if (sizeof(ur_device_usm_access_capability_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_usm_access_capability_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_device_usm_access_capability_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_USM_SINGLE_SHARED_SUPPORT: {
+                    const ur_device_usm_access_capability_flags_t *tptr = (const ur_device_usm_access_capability_flags_t *)ptr;
+                    if (sizeof(ur_device_usm_access_capability_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_usm_access_capability_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_device_usm_access_capability_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_USM_CROSS_SHARED_SUPPORT: {
+                    const ur_device_usm_access_capability_flags_t *tptr = (const ur_device_usm_access_capability_flags_t *)ptr;
+                    if (sizeof(ur_device_usm_access_capability_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_usm_access_capability_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_device_usm_access_capability_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_USM_SYSTEM_SHARED_SUPPORT: {
+                    const ur_device_usm_access_capability_flags_t *tptr = (const ur_device_usm_access_capability_flags_t *)ptr;
+                    if (sizeof(ur_device_usm_access_capability_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_usm_access_capability_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_device_usm_access_capability_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_UUID: {
+                    
+                    const uint8_t *tptr = (const uint8_t *)ptr;
+                            os << "{";
+                            size_t nelems = size / sizeof(uint8_t);
+                            for (size_t i = 0; i < nelems; ++i) {
+                                if (i != 0) {
+                                    os << ", ";
+                                }
+                                
+        os << 
+                                    tptr[i]
+                                ;
+
+                            }
+                            os << "}";
+                } break;
+                case UR_DEVICE_INFO_PCI_ADDRESS: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_DEVICE_INFO_GPU_EU_COUNT: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_GPU_EU_SIMD_WIDTH: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_GPU_EU_SLICES: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_GPU_EU_COUNT_PER_SUBSLICE: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_GPU_SUBSLICES_PER_SLICE: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_GPU_HW_THREADS_PER_EU: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MAX_MEMORY_BANDWIDTH: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_IMAGE_SRGB: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_BUILD_ON_SUBDEVICE: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_ATOMIC_64: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_ATOMIC_MEMORY_ORDER_CAPABILITIES: {
+                    const ur_memory_order_capability_flags_t *tptr = (const ur_memory_order_capability_flags_t *)ptr;
+                    if (sizeof(ur_memory_order_capability_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_memory_order_capability_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_memory_order_capability_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_ATOMIC_MEMORY_SCOPE_CAPABILITIES: {
+                    const ur_memory_scope_capability_flags_t *tptr = (const ur_memory_scope_capability_flags_t *)ptr;
+                    if (sizeof(ur_memory_scope_capability_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_memory_scope_capability_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_memory_scope_capability_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_ATOMIC_FENCE_ORDER_CAPABILITIES: {
+                    const ur_memory_order_capability_flags_t *tptr = (const ur_memory_order_capability_flags_t *)ptr;
+                    if (sizeof(ur_memory_order_capability_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_memory_order_capability_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_memory_order_capability_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_ATOMIC_FENCE_SCOPE_CAPABILITIES: {
+                    const ur_memory_scope_capability_flags_t *tptr = (const ur_memory_scope_capability_flags_t *)ptr;
+                    if (sizeof(ur_memory_scope_capability_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_memory_scope_capability_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_memory_scope_capability_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_BFLOAT16: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MAX_COMPUTE_QUEUE_INDICES: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_KERNEL_SET_SPECIALIZATION_CONSTANTS: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MEMORY_BUS_WIDTH: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MAX_WORK_GROUPS_3D: {
+                    
+                    const size_t *tptr = (const size_t *)ptr;
+                            os << "{";
+                            size_t nelems = size / sizeof(size_t);
+                            for (size_t i = 0; i < nelems; ++i) {
+                                if (i != 0) {
+                                    os << ", ";
+                                }
+                                
+        os << 
+                                    tptr[i]
+                                ;
+
+                            }
+                            os << "}";
+                } break;
+                case UR_DEVICE_INFO_ASYNC_BARRIER: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MEM_CHANNEL_SUPPORT: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_HOST_PIPE_READ_WRITE_SUPPORTED: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MAX_REGISTERS_PER_WORK_GROUP: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_IP_VERSION: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_VIRTUAL_MEMORY_SUPPORT: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_ESIMD_SUPPORT: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_COMPONENT_DEVICES: {
+                    
+                    const ur_device_handle_t *tptr = (const ur_device_handle_t *)ptr;
+                            os << "{";
+                            size_t nelems = size / sizeof(ur_device_handle_t);
+                            for (size_t i = 0; i < nelems; ++i) {
+                                if (i != 0) {
+                                    os << ", ";
+                                }
+                                
+        ur::details::printPtr(os, 
+                                    tptr[i]
+                                );
+
+                            }
+                            os << "}";
+                } break;
+                case UR_DEVICE_INFO_COMPOSITE_DEVICE: {
+                    const ur_device_handle_t *tptr = (const ur_device_handle_t *)ptr;
+                    if (sizeof(ur_device_handle_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_handle_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printPtr(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_GLOBAL_VARIABLE_SUPPORT: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_COMMAND_BUFFER_SUPPORT_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_COMMAND_BUFFER_UPDATE_CAPABILITIES_EXP: {
+                    const ur_device_command_buffer_update_capability_flags_t *tptr = (const ur_device_command_buffer_update_capability_flags_t *)ptr;
+                    if (sizeof(ur_device_command_buffer_update_capability_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_command_buffer_update_capability_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_device_command_buffer_update_capability_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_CLUSTER_LAUNCH_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_BINDLESS_IMAGES_SUPPORT_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_BINDLESS_IMAGES_SHARED_USM_SUPPORT_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_BINDLESS_IMAGES_1D_USM_SUPPORT_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_BINDLESS_IMAGES_2D_USM_SUPPORT_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_IMAGE_PITCH_ALIGN_EXP: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MAX_IMAGE_LINEAR_WIDTH_EXP: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MAX_IMAGE_LINEAR_HEIGHT_EXP: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MAX_IMAGE_LINEAR_PITCH_EXP: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MIPMAP_SUPPORT_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MIPMAP_ANISOTROPY_SUPPORT_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MIPMAP_MAX_ANISOTROPY_EXP: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_MIPMAP_LEVEL_REFERENCE_SUPPORT_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_EXTERNAL_MEMORY_IMPORT_SUPPORT_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_EXTERNAL_SEMAPHORE_IMPORT_SUPPORT_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_CUBEMAP_SUPPORT_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_CUBEMAP_SEAMLESS_FILTERING_SUPPORT_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_USM_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_USM_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_3D_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_TIMESTAMP_RECORDING_SUPPORT_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_IMAGE_ARRAY_SUPPORT_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_BINDLESS_UNIQUE_ADDRESSING_PER_DIM_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_BINDLESS_SAMPLE_1D_USM_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_BINDLESS_SAMPLE_2D_USM_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_DEVICE_INFO_ENQUEUE_NATIVE_COMMAND_SUPPORT_EXP: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_device_affinity_domain_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_affinity_domain_flag_t value) {
+        switch (value) {
+                case UR_DEVICE_AFFINITY_DOMAIN_FLAG_NUMA:
+                    os << "UR_DEVICE_AFFINITY_DOMAIN_FLAG_NUMA";
+                    break;
+                case UR_DEVICE_AFFINITY_DOMAIN_FLAG_L4_CACHE:
+                    os << "UR_DEVICE_AFFINITY_DOMAIN_FLAG_L4_CACHE";
+                    break;
+                case UR_DEVICE_AFFINITY_DOMAIN_FLAG_L3_CACHE:
+                    os << "UR_DEVICE_AFFINITY_DOMAIN_FLAG_L3_CACHE";
+                    break;
+                case UR_DEVICE_AFFINITY_DOMAIN_FLAG_L2_CACHE:
+                    os << "UR_DEVICE_AFFINITY_DOMAIN_FLAG_L2_CACHE";
+                    break;
+                case UR_DEVICE_AFFINITY_DOMAIN_FLAG_L1_CACHE:
+                    os << "UR_DEVICE_AFFINITY_DOMAIN_FLAG_L1_CACHE";
+                    break;
+                case UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE:
+                    os << "UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_device_affinity_domain_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_device_affinity_domain_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_DEVICE_AFFINITY_DOMAIN_FLAG_NUMA) == (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_NUMA) {
+                val ^= (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_NUMA;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_AFFINITY_DOMAIN_FLAG_NUMA;
+            }
+            
+            if ((val & UR_DEVICE_AFFINITY_DOMAIN_FLAG_L4_CACHE) == (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_L4_CACHE) {
+                val ^= (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_L4_CACHE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_AFFINITY_DOMAIN_FLAG_L4_CACHE;
+            }
+            
+            if ((val & UR_DEVICE_AFFINITY_DOMAIN_FLAG_L3_CACHE) == (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_L3_CACHE) {
+                val ^= (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_L3_CACHE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_AFFINITY_DOMAIN_FLAG_L3_CACHE;
+            }
+            
+            if ((val & UR_DEVICE_AFFINITY_DOMAIN_FLAG_L2_CACHE) == (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_L2_CACHE) {
+                val ^= (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_L2_CACHE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_AFFINITY_DOMAIN_FLAG_L2_CACHE;
+            }
+            
+            if ((val & UR_DEVICE_AFFINITY_DOMAIN_FLAG_L1_CACHE) == (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_L1_CACHE) {
+                val ^= (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_L1_CACHE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_AFFINITY_DOMAIN_FLAG_L1_CACHE;
+            }
+            
+            if ((val & UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE) == (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE) {
+                val ^= (uint32_t)UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_device_partition_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_partition_t value) {
+        switch (value) {
+                case UR_DEVICE_PARTITION_EQUALLY:
+                    os << "UR_DEVICE_PARTITION_EQUALLY";
+                    break;
+                case UR_DEVICE_PARTITION_BY_COUNTS:
+                    os << "UR_DEVICE_PARTITION_BY_COUNTS";
+                    break;
+                case UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN:
+                    os << "UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN";
+                    break;
+                case UR_DEVICE_PARTITION_BY_CSLICE:
+                    os << "UR_DEVICE_PARTITION_BY_CSLICE";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+namespace ur::details {
 
-    os << ", ";
-    os << ".pIL = ";
+    ///////////////////////////////////////////////////////////////////////////////
+    // @brief Print ur_device_partition_value_t union
+    inline ur_result_t printUnion(
+    std::ostream &os,
+    const union ur_device_partition_value_t params,
+    const enum ur_device_partition_t tag
+){
+    os << "(union ur_device_partition_value_t){";
 
-    ur::details::printPtr(os,
-                          *(params->ppIL));
+    switch(tag){
+    case UR_DEVICE_PARTITION_EQUALLY:
+        
+    
+        os << ".equally = ";
+        
+        os << 
+            (params.equally)
+        ;
 
-    os << ", ";
-    os << ".length = ";
 
-    os << *(params->plength);
+        break;
+    case UR_DEVICE_PARTITION_BY_COUNTS:
+        
+    
+        os << ".count = ";
+        
+        os << 
+            (params.count)
+        ;
 
-    os << ", ";
-    os << ".pProperties = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
+        break;
+    case UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN:
+        
+    
+        os << ".affinity_domain = ";
+        
+        ur::details::printFlag<ur_device_affinity_domain_flag_t>(os, 
+            (params.affinity_domain)
+        );
 
-    os << ", ";
-    os << ".phProgram = ";
 
-    ur::details::printPtr(os,
-                          *(params->pphProgram));
+        break;
+    default:
+        os << "<unknown>";
+        return UR_RESULT_ERROR_INVALID_ENUMERATION;
+    }
+    os << "}";
+    return UR_RESULT_SUCCESS;
+}
+} // namespace ur::details
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_device_partition_property_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, const struct ur_device_partition_property_t params) {
+    os << "(struct ur_device_partition_property_t){";
+    
+        
+    
+        os << ".type = ";
+        
+        os << 
+            (params.type)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".value = ";
+        ur::details::printUnion(os, (params.value), params.type);
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_create_with_binary_params_t type
+/// @brief Print operator for the ur_device_partition_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_create_with_binary_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".hDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->phDevice));
-
-    os << ", ";
-    os << ".size = ";
-
-    os << *(params->psize);
-
-    os << ", ";
-    os << ".pBinary = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppBinary));
-
-    os << ", ";
-    os << ".pProperties = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
-
-    os << ", ";
-    os << ".phProgram = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_device_partition_properties_t params) {
+    os << "(struct ur_device_partition_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            (params.pProperties)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".PropCount = ";
+        
+        os << 
+            (params.PropCount)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->pphProgram));
 
+    os << "}";
     return os;
 }
-
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_device_fp_capability_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_fp_capability_flag_t value) {
+        switch (value) {
+                case UR_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT:
+                    os << "UR_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT";
+                    break;
+                case UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST:
+                    os << "UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST";
+                    break;
+                case UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO:
+                    os << "UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO";
+                    break;
+                case UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF:
+                    os << "UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF";
+                    break;
+                case UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN:
+                    os << "UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN";
+                    break;
+                case UR_DEVICE_FP_CAPABILITY_FLAG_DENORM:
+                    os << "UR_DEVICE_FP_CAPABILITY_FLAG_DENORM";
+                    break;
+                case UR_DEVICE_FP_CAPABILITY_FLAG_FMA:
+                    os << "UR_DEVICE_FP_CAPABILITY_FLAG_FMA";
+                    break;
+                case UR_DEVICE_FP_CAPABILITY_FLAG_SOFT_FLOAT:
+                    os << "UR_DEVICE_FP_CAPABILITY_FLAG_SOFT_FLOAT";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_device_fp_capability_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_device_fp_capability_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT) == (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT) {
+                val ^= (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT;
+            }
+            
+            if ((val & UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST) == (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST) {
+                val ^= (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST;
+            }
+            
+            if ((val & UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO) == (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO) {
+                val ^= (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO;
+            }
+            
+            if ((val & UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF) == (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF) {
+                val ^= (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF;
+            }
+            
+            if ((val & UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN) == (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN) {
+                val ^= (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN;
+            }
+            
+            if ((val & UR_DEVICE_FP_CAPABILITY_FLAG_DENORM) == (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_DENORM) {
+                val ^= (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_DENORM;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_FP_CAPABILITY_FLAG_DENORM;
+            }
+            
+            if ((val & UR_DEVICE_FP_CAPABILITY_FLAG_FMA) == (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_FMA) {
+                val ^= (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_FMA;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_FP_CAPABILITY_FLAG_FMA;
+            }
+            
+            if ((val & UR_DEVICE_FP_CAPABILITY_FLAG_SOFT_FLOAT) == (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_SOFT_FLOAT) {
+                val ^= (uint32_t)UR_DEVICE_FP_CAPABILITY_FLAG_SOFT_FLOAT;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_FP_CAPABILITY_FLAG_SOFT_FLOAT;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_device_mem_cache_type_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_mem_cache_type_t value) {
+        switch (value) {
+                case UR_DEVICE_MEM_CACHE_TYPE_NONE:
+                    os << "UR_DEVICE_MEM_CACHE_TYPE_NONE";
+                    break;
+                case UR_DEVICE_MEM_CACHE_TYPE_READ_ONLY_CACHE:
+                    os << "UR_DEVICE_MEM_CACHE_TYPE_READ_ONLY_CACHE";
+                    break;
+                case UR_DEVICE_MEM_CACHE_TYPE_READ_WRITE_CACHE:
+                    os << "UR_DEVICE_MEM_CACHE_TYPE_READ_WRITE_CACHE";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_device_local_mem_type_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_local_mem_type_t value) {
+        switch (value) {
+                case UR_DEVICE_LOCAL_MEM_TYPE_NONE:
+                    os << "UR_DEVICE_LOCAL_MEM_TYPE_NONE";
+                    break;
+                case UR_DEVICE_LOCAL_MEM_TYPE_LOCAL:
+                    os << "UR_DEVICE_LOCAL_MEM_TYPE_LOCAL";
+                    break;
+                case UR_DEVICE_LOCAL_MEM_TYPE_GLOBAL:
+                    os << "UR_DEVICE_LOCAL_MEM_TYPE_GLOBAL";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_device_exec_capability_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_exec_capability_flag_t value) {
+        switch (value) {
+                case UR_DEVICE_EXEC_CAPABILITY_FLAG_KERNEL:
+                    os << "UR_DEVICE_EXEC_CAPABILITY_FLAG_KERNEL";
+                    break;
+                case UR_DEVICE_EXEC_CAPABILITY_FLAG_NATIVE_KERNEL:
+                    os << "UR_DEVICE_EXEC_CAPABILITY_FLAG_NATIVE_KERNEL";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_device_exec_capability_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_device_exec_capability_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_DEVICE_EXEC_CAPABILITY_FLAG_KERNEL) == (uint32_t)UR_DEVICE_EXEC_CAPABILITY_FLAG_KERNEL) {
+                val ^= (uint32_t)UR_DEVICE_EXEC_CAPABILITY_FLAG_KERNEL;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_EXEC_CAPABILITY_FLAG_KERNEL;
+            }
+            
+            if ((val & UR_DEVICE_EXEC_CAPABILITY_FLAG_NATIVE_KERNEL) == (uint32_t)UR_DEVICE_EXEC_CAPABILITY_FLAG_NATIVE_KERNEL) {
+                val ^= (uint32_t)UR_DEVICE_EXEC_CAPABILITY_FLAG_NATIVE_KERNEL;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_EXEC_CAPABILITY_FLAG_NATIVE_KERNEL;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_build_params_t type
+/// @brief Print operator for the ur_device_native_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_build_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".hProgram = ";
-
-    ur::details::printPtr(os,
-                          *(params->phProgram));
-
-    os << ", ";
-    os << ".pOptions = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_device_native_properties_t params) {
+    os << "(struct ur_device_native_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".isNativeHandleOwned = ";
+        
+        os << 
+            (params.isNativeHandleOwned)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->ppOptions));
 
+    os << "}";
     return os;
 }
-
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_memory_order_capability_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_memory_order_capability_flag_t value) {
+        switch (value) {
+                case UR_MEMORY_ORDER_CAPABILITY_FLAG_RELAXED:
+                    os << "UR_MEMORY_ORDER_CAPABILITY_FLAG_RELAXED";
+                    break;
+                case UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQUIRE:
+                    os << "UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQUIRE";
+                    break;
+                case UR_MEMORY_ORDER_CAPABILITY_FLAG_RELEASE:
+                    os << "UR_MEMORY_ORDER_CAPABILITY_FLAG_RELEASE";
+                    break;
+                case UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQ_REL:
+                    os << "UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQ_REL";
+                    break;
+                case UR_MEMORY_ORDER_CAPABILITY_FLAG_SEQ_CST:
+                    os << "UR_MEMORY_ORDER_CAPABILITY_FLAG_SEQ_CST";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_memory_order_capability_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_memory_order_capability_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_MEMORY_ORDER_CAPABILITY_FLAG_RELAXED) == (uint32_t)UR_MEMORY_ORDER_CAPABILITY_FLAG_RELAXED) {
+                val ^= (uint32_t)UR_MEMORY_ORDER_CAPABILITY_FLAG_RELAXED;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_MEMORY_ORDER_CAPABILITY_FLAG_RELAXED;
+            }
+            
+            if ((val & UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQUIRE) == (uint32_t)UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQUIRE) {
+                val ^= (uint32_t)UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQUIRE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQUIRE;
+            }
+            
+            if ((val & UR_MEMORY_ORDER_CAPABILITY_FLAG_RELEASE) == (uint32_t)UR_MEMORY_ORDER_CAPABILITY_FLAG_RELEASE) {
+                val ^= (uint32_t)UR_MEMORY_ORDER_CAPABILITY_FLAG_RELEASE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_MEMORY_ORDER_CAPABILITY_FLAG_RELEASE;
+            }
+            
+            if ((val & UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQ_REL) == (uint32_t)UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQ_REL) {
+                val ^= (uint32_t)UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQ_REL;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQ_REL;
+            }
+            
+            if ((val & UR_MEMORY_ORDER_CAPABILITY_FLAG_SEQ_CST) == (uint32_t)UR_MEMORY_ORDER_CAPABILITY_FLAG_SEQ_CST) {
+                val ^= (uint32_t)UR_MEMORY_ORDER_CAPABILITY_FLAG_SEQ_CST;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_MEMORY_ORDER_CAPABILITY_FLAG_SEQ_CST;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_memory_scope_capability_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_memory_scope_capability_flag_t value) {
+        switch (value) {
+                case UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_ITEM:
+                    os << "UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_ITEM";
+                    break;
+                case UR_MEMORY_SCOPE_CAPABILITY_FLAG_SUB_GROUP:
+                    os << "UR_MEMORY_SCOPE_CAPABILITY_FLAG_SUB_GROUP";
+                    break;
+                case UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_GROUP:
+                    os << "UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_GROUP";
+                    break;
+                case UR_MEMORY_SCOPE_CAPABILITY_FLAG_DEVICE:
+                    os << "UR_MEMORY_SCOPE_CAPABILITY_FLAG_DEVICE";
+                    break;
+                case UR_MEMORY_SCOPE_CAPABILITY_FLAG_SYSTEM:
+                    os << "UR_MEMORY_SCOPE_CAPABILITY_FLAG_SYSTEM";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_memory_scope_capability_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_memory_scope_capability_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_ITEM) == (uint32_t)UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_ITEM) {
+                val ^= (uint32_t)UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_ITEM;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_ITEM;
+            }
+            
+            if ((val & UR_MEMORY_SCOPE_CAPABILITY_FLAG_SUB_GROUP) == (uint32_t)UR_MEMORY_SCOPE_CAPABILITY_FLAG_SUB_GROUP) {
+                val ^= (uint32_t)UR_MEMORY_SCOPE_CAPABILITY_FLAG_SUB_GROUP;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_MEMORY_SCOPE_CAPABILITY_FLAG_SUB_GROUP;
+            }
+            
+            if ((val & UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_GROUP) == (uint32_t)UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_GROUP) {
+                val ^= (uint32_t)UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_GROUP;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_GROUP;
+            }
+            
+            if ((val & UR_MEMORY_SCOPE_CAPABILITY_FLAG_DEVICE) == (uint32_t)UR_MEMORY_SCOPE_CAPABILITY_FLAG_DEVICE) {
+                val ^= (uint32_t)UR_MEMORY_SCOPE_CAPABILITY_FLAG_DEVICE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_MEMORY_SCOPE_CAPABILITY_FLAG_DEVICE;
+            }
+            
+            if ((val & UR_MEMORY_SCOPE_CAPABILITY_FLAG_SYSTEM) == (uint32_t)UR_MEMORY_SCOPE_CAPABILITY_FLAG_SYSTEM) {
+                val ^= (uint32_t)UR_MEMORY_SCOPE_CAPABILITY_FLAG_SYSTEM;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_MEMORY_SCOPE_CAPABILITY_FLAG_SYSTEM;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_device_usm_access_capability_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_usm_access_capability_flag_t value) {
+        switch (value) {
+                case UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ACCESS:
+                    os << "UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ACCESS";
+                    break;
+                case UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_ACCESS:
+                    os << "UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_ACCESS";
+                    break;
+                case UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_CONCURRENT_ACCESS:
+                    os << "UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_CONCURRENT_ACCESS";
+                    break;
+                case UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_CONCURRENT_ACCESS:
+                    os << "UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_CONCURRENT_ACCESS";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_device_usm_access_capability_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_device_usm_access_capability_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ACCESS) == (uint32_t)UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ACCESS) {
+                val ^= (uint32_t)UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ACCESS;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ACCESS;
+            }
+            
+            if ((val & UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_ACCESS) == (uint32_t)UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_ACCESS) {
+                val ^= (uint32_t)UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_ACCESS;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_ACCESS;
+            }
+            
+            if ((val & UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_CONCURRENT_ACCESS) == (uint32_t)UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_CONCURRENT_ACCESS) {
+                val ^= (uint32_t)UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_CONCURRENT_ACCESS;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_CONCURRENT_ACCESS;
+            }
+            
+            if ((val & UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_CONCURRENT_ACCESS) == (uint32_t)UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_CONCURRENT_ACCESS) {
+                val ^= (uint32_t)UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_CONCURRENT_ACCESS;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_USM_ACCESS_CAPABILITY_FLAG_ATOMIC_CONCURRENT_ACCESS;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_context_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_context_flag_t value) {
+        switch (value) {
+                case UR_CONTEXT_FLAG_TBD:
+                    os << "UR_CONTEXT_FLAG_TBD";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_context_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_context_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_CONTEXT_FLAG_TBD) == (uint32_t)UR_CONTEXT_FLAG_TBD) {
+                val ^= (uint32_t)UR_CONTEXT_FLAG_TBD;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_CONTEXT_FLAG_TBD;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_build_exp_params_t type
+/// @brief Print operator for the ur_context_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_build_exp_params_t *params) {
-
-    os << ".hProgram = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_context_properties_t params) {
+    os << "(struct ur_context_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".flags = ";
+        
+        ur::details::printFlag<ur_context_flag_t>(os, 
+            (params.flags)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phProgram));
 
-    os << ", ";
-    os << ".numDevices = ";
+    os << "}";
+    return os;
+}
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_context_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_context_info_t value) {
+        switch (value) {
+                case UR_CONTEXT_INFO_NUM_DEVICES:
+                    os << "UR_CONTEXT_INFO_NUM_DEVICES";
+                    break;
+                case UR_CONTEXT_INFO_DEVICES:
+                    os << "UR_CONTEXT_INFO_DEVICES";
+                    break;
+                case UR_CONTEXT_INFO_REFERENCE_COUNT:
+                    os << "UR_CONTEXT_INFO_REFERENCE_COUNT";
+                    break;
+                case UR_CONTEXT_INFO_USM_MEMCPY2D_SUPPORT:
+                    os << "UR_CONTEXT_INFO_USM_MEMCPY2D_SUPPORT";
+                    break;
+                case UR_CONTEXT_INFO_USM_FILL2D_SUPPORT:
+                    os << "UR_CONTEXT_INFO_USM_FILL2D_SUPPORT";
+                    break;
+                case UR_CONTEXT_INFO_ATOMIC_MEMORY_ORDER_CAPABILITIES:
+                    os << "UR_CONTEXT_INFO_ATOMIC_MEMORY_ORDER_CAPABILITIES";
+                    break;
+                case UR_CONTEXT_INFO_ATOMIC_MEMORY_SCOPE_CAPABILITIES:
+                    os << "UR_CONTEXT_INFO_ATOMIC_MEMORY_SCOPE_CAPABILITIES";
+                    break;
+                case UR_CONTEXT_INFO_ATOMIC_FENCE_ORDER_CAPABILITIES:
+                    os << "UR_CONTEXT_INFO_ATOMIC_FENCE_ORDER_CAPABILITIES";
+                    break;
+                case UR_CONTEXT_INFO_ATOMIC_FENCE_SCOPE_CAPABILITIES:
+                    os << "UR_CONTEXT_INFO_ATOMIC_FENCE_SCOPE_CAPABILITIES";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_context_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_context_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_CONTEXT_INFO_NUM_DEVICES: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_CONTEXT_INFO_DEVICES: {
+                    
+                    const ur_device_handle_t *tptr = (const ur_device_handle_t *)ptr;
+                            os << "{";
+                            size_t nelems = size / sizeof(ur_device_handle_t);
+                            for (size_t i = 0; i < nelems; ++i) {
+                                if (i != 0) {
+                                    os << ", ";
+                                }
+                                
+        ur::details::printPtr(os, 
+                                    tptr[i]
+                                );
+
+                            }
+                            os << "}";
+                } break;
+                case UR_CONTEXT_INFO_REFERENCE_COUNT: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_CONTEXT_INFO_USM_MEMCPY2D_SUPPORT: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_CONTEXT_INFO_USM_FILL2D_SUPPORT: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_CONTEXT_INFO_ATOMIC_MEMORY_ORDER_CAPABILITIES: {
+                    const ur_memory_order_capability_flags_t *tptr = (const ur_memory_order_capability_flags_t *)ptr;
+                    if (sizeof(ur_memory_order_capability_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_memory_order_capability_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_memory_order_capability_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_CONTEXT_INFO_ATOMIC_MEMORY_SCOPE_CAPABILITIES: {
+                    const ur_memory_scope_capability_flags_t *tptr = (const ur_memory_scope_capability_flags_t *)ptr;
+                    if (sizeof(ur_memory_scope_capability_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_memory_scope_capability_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_memory_scope_capability_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_CONTEXT_INFO_ATOMIC_FENCE_ORDER_CAPABILITIES: {
+                    const ur_memory_order_capability_flags_t *tptr = (const ur_memory_order_capability_flags_t *)ptr;
+                    if (sizeof(ur_memory_order_capability_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_memory_order_capability_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_memory_order_capability_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_CONTEXT_INFO_ATOMIC_FENCE_SCOPE_CAPABILITIES: {
+                    const ur_memory_scope_capability_flags_t *tptr = (const ur_memory_scope_capability_flags_t *)ptr;
+                    if (sizeof(ur_memory_scope_capability_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_memory_scope_capability_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_memory_scope_capability_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
 
-    os << *(params->pnumDevices);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_context_native_properties_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, const struct ur_context_native_properties_t params) {
+    os << "(struct ur_context_native_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".isNativeHandleOwned = ";
+        
+        os << 
+            (params.isNativeHandleOwned)
+        ;
 
-    os << ", ";
-    os << ".phDevices = {";
-    for (size_t i = 0; *(params->pphDevices) != NULL && i < *params->pnumDevices; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphDevices))[i]);
-    }
     os << "}";
+    return os;
+}
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_mem_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_mem_flag_t value) {
+        switch (value) {
+                case UR_MEM_FLAG_READ_WRITE:
+                    os << "UR_MEM_FLAG_READ_WRITE";
+                    break;
+                case UR_MEM_FLAG_WRITE_ONLY:
+                    os << "UR_MEM_FLAG_WRITE_ONLY";
+                    break;
+                case UR_MEM_FLAG_READ_ONLY:
+                    os << "UR_MEM_FLAG_READ_ONLY";
+                    break;
+                case UR_MEM_FLAG_USE_HOST_POINTER:
+                    os << "UR_MEM_FLAG_USE_HOST_POINTER";
+                    break;
+                case UR_MEM_FLAG_ALLOC_HOST_POINTER:
+                    os << "UR_MEM_FLAG_ALLOC_HOST_POINTER";
+                    break;
+                case UR_MEM_FLAG_ALLOC_COPY_HOST_POINTER:
+                    os << "UR_MEM_FLAG_ALLOC_COPY_HOST_POINTER";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_mem_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_mem_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_MEM_FLAG_READ_WRITE) == (uint32_t)UR_MEM_FLAG_READ_WRITE) {
+                val ^= (uint32_t)UR_MEM_FLAG_READ_WRITE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_MEM_FLAG_READ_WRITE;
+            }
+            
+            if ((val & UR_MEM_FLAG_WRITE_ONLY) == (uint32_t)UR_MEM_FLAG_WRITE_ONLY) {
+                val ^= (uint32_t)UR_MEM_FLAG_WRITE_ONLY;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_MEM_FLAG_WRITE_ONLY;
+            }
+            
+            if ((val & UR_MEM_FLAG_READ_ONLY) == (uint32_t)UR_MEM_FLAG_READ_ONLY) {
+                val ^= (uint32_t)UR_MEM_FLAG_READ_ONLY;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_MEM_FLAG_READ_ONLY;
+            }
+            
+            if ((val & UR_MEM_FLAG_USE_HOST_POINTER) == (uint32_t)UR_MEM_FLAG_USE_HOST_POINTER) {
+                val ^= (uint32_t)UR_MEM_FLAG_USE_HOST_POINTER;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_MEM_FLAG_USE_HOST_POINTER;
+            }
+            
+            if ((val & UR_MEM_FLAG_ALLOC_HOST_POINTER) == (uint32_t)UR_MEM_FLAG_ALLOC_HOST_POINTER) {
+                val ^= (uint32_t)UR_MEM_FLAG_ALLOC_HOST_POINTER;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_MEM_FLAG_ALLOC_HOST_POINTER;
+            }
+            
+            if ((val & UR_MEM_FLAG_ALLOC_COPY_HOST_POINTER) == (uint32_t)UR_MEM_FLAG_ALLOC_COPY_HOST_POINTER) {
+                val ^= (uint32_t)UR_MEM_FLAG_ALLOC_COPY_HOST_POINTER;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_MEM_FLAG_ALLOC_COPY_HOST_POINTER;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_mem_type_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_mem_type_t value) {
+        switch (value) {
+                case UR_MEM_TYPE_IMAGE2D:
+                    os << "UR_MEM_TYPE_IMAGE2D";
+                    break;
+                case UR_MEM_TYPE_IMAGE3D:
+                    os << "UR_MEM_TYPE_IMAGE3D";
+                    break;
+                case UR_MEM_TYPE_IMAGE2D_ARRAY:
+                    os << "UR_MEM_TYPE_IMAGE2D_ARRAY";
+                    break;
+                case UR_MEM_TYPE_IMAGE1D:
+                    os << "UR_MEM_TYPE_IMAGE1D";
+                    break;
+                case UR_MEM_TYPE_IMAGE1D_ARRAY:
+                    os << "UR_MEM_TYPE_IMAGE1D_ARRAY";
+                    break;
+                case UR_MEM_TYPE_IMAGE_CUBEMAP_EXP:
+                    os << "UR_MEM_TYPE_IMAGE_CUBEMAP_EXP";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_mem_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_mem_info_t value) {
+        switch (value) {
+                case UR_MEM_INFO_SIZE:
+                    os << "UR_MEM_INFO_SIZE";
+                    break;
+                case UR_MEM_INFO_CONTEXT:
+                    os << "UR_MEM_INFO_CONTEXT";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_mem_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_mem_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_MEM_INFO_SIZE: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_MEM_INFO_CONTEXT: {
+                    const ur_context_handle_t *tptr = (const ur_context_handle_t *)ptr;
+                    if (sizeof(ur_context_handle_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_context_handle_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printPtr(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_image_channel_order_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_image_channel_order_t value) {
+        switch (value) {
+                case UR_IMAGE_CHANNEL_ORDER_A:
+                    os << "UR_IMAGE_CHANNEL_ORDER_A";
+                    break;
+                case UR_IMAGE_CHANNEL_ORDER_R:
+                    os << "UR_IMAGE_CHANNEL_ORDER_R";
+                    break;
+                case UR_IMAGE_CHANNEL_ORDER_RG:
+                    os << "UR_IMAGE_CHANNEL_ORDER_RG";
+                    break;
+                case UR_IMAGE_CHANNEL_ORDER_RA:
+                    os << "UR_IMAGE_CHANNEL_ORDER_RA";
+                    break;
+                case UR_IMAGE_CHANNEL_ORDER_RGB:
+                    os << "UR_IMAGE_CHANNEL_ORDER_RGB";
+                    break;
+                case UR_IMAGE_CHANNEL_ORDER_RGBA:
+                    os << "UR_IMAGE_CHANNEL_ORDER_RGBA";
+                    break;
+                case UR_IMAGE_CHANNEL_ORDER_BGRA:
+                    os << "UR_IMAGE_CHANNEL_ORDER_BGRA";
+                    break;
+                case UR_IMAGE_CHANNEL_ORDER_ARGB:
+                    os << "UR_IMAGE_CHANNEL_ORDER_ARGB";
+                    break;
+                case UR_IMAGE_CHANNEL_ORDER_ABGR:
+                    os << "UR_IMAGE_CHANNEL_ORDER_ABGR";
+                    break;
+                case UR_IMAGE_CHANNEL_ORDER_INTENSITY:
+                    os << "UR_IMAGE_CHANNEL_ORDER_INTENSITY";
+                    break;
+                case UR_IMAGE_CHANNEL_ORDER_LUMINANCE:
+                    os << "UR_IMAGE_CHANNEL_ORDER_LUMINANCE";
+                    break;
+                case UR_IMAGE_CHANNEL_ORDER_RX:
+                    os << "UR_IMAGE_CHANNEL_ORDER_RX";
+                    break;
+                case UR_IMAGE_CHANNEL_ORDER_RGX:
+                    os << "UR_IMAGE_CHANNEL_ORDER_RGX";
+                    break;
+                case UR_IMAGE_CHANNEL_ORDER_RGBX:
+                    os << "UR_IMAGE_CHANNEL_ORDER_RGBX";
+                    break;
+                case UR_IMAGE_CHANNEL_ORDER_SRGBA:
+                    os << "UR_IMAGE_CHANNEL_ORDER_SRGBA";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_image_channel_type_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_image_channel_type_t value) {
+        switch (value) {
+                case UR_IMAGE_CHANNEL_TYPE_SNORM_INT8:
+                    os << "UR_IMAGE_CHANNEL_TYPE_SNORM_INT8";
+                    break;
+                case UR_IMAGE_CHANNEL_TYPE_SNORM_INT16:
+                    os << "UR_IMAGE_CHANNEL_TYPE_SNORM_INT16";
+                    break;
+                case UR_IMAGE_CHANNEL_TYPE_UNORM_INT8:
+                    os << "UR_IMAGE_CHANNEL_TYPE_UNORM_INT8";
+                    break;
+                case UR_IMAGE_CHANNEL_TYPE_UNORM_INT16:
+                    os << "UR_IMAGE_CHANNEL_TYPE_UNORM_INT16";
+                    break;
+                case UR_IMAGE_CHANNEL_TYPE_UNORM_SHORT_565:
+                    os << "UR_IMAGE_CHANNEL_TYPE_UNORM_SHORT_565";
+                    break;
+                case UR_IMAGE_CHANNEL_TYPE_UNORM_SHORT_555:
+                    os << "UR_IMAGE_CHANNEL_TYPE_UNORM_SHORT_555";
+                    break;
+                case UR_IMAGE_CHANNEL_TYPE_INT_101010:
+                    os << "UR_IMAGE_CHANNEL_TYPE_INT_101010";
+                    break;
+                case UR_IMAGE_CHANNEL_TYPE_SIGNED_INT8:
+                    os << "UR_IMAGE_CHANNEL_TYPE_SIGNED_INT8";
+                    break;
+                case UR_IMAGE_CHANNEL_TYPE_SIGNED_INT16:
+                    os << "UR_IMAGE_CHANNEL_TYPE_SIGNED_INT16";
+                    break;
+                case UR_IMAGE_CHANNEL_TYPE_SIGNED_INT32:
+                    os << "UR_IMAGE_CHANNEL_TYPE_SIGNED_INT32";
+                    break;
+                case UR_IMAGE_CHANNEL_TYPE_UNSIGNED_INT8:
+                    os << "UR_IMAGE_CHANNEL_TYPE_UNSIGNED_INT8";
+                    break;
+                case UR_IMAGE_CHANNEL_TYPE_UNSIGNED_INT16:
+                    os << "UR_IMAGE_CHANNEL_TYPE_UNSIGNED_INT16";
+                    break;
+                case UR_IMAGE_CHANNEL_TYPE_UNSIGNED_INT32:
+                    os << "UR_IMAGE_CHANNEL_TYPE_UNSIGNED_INT32";
+                    break;
+                case UR_IMAGE_CHANNEL_TYPE_HALF_FLOAT:
+                    os << "UR_IMAGE_CHANNEL_TYPE_HALF_FLOAT";
+                    break;
+                case UR_IMAGE_CHANNEL_TYPE_FLOAT:
+                    os << "UR_IMAGE_CHANNEL_TYPE_FLOAT";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_image_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_image_info_t value) {
+        switch (value) {
+                case UR_IMAGE_INFO_FORMAT:
+                    os << "UR_IMAGE_INFO_FORMAT";
+                    break;
+                case UR_IMAGE_INFO_ELEMENT_SIZE:
+                    os << "UR_IMAGE_INFO_ELEMENT_SIZE";
+                    break;
+                case UR_IMAGE_INFO_ROW_PITCH:
+                    os << "UR_IMAGE_INFO_ROW_PITCH";
+                    break;
+                case UR_IMAGE_INFO_SLICE_PITCH:
+                    os << "UR_IMAGE_INFO_SLICE_PITCH";
+                    break;
+                case UR_IMAGE_INFO_WIDTH:
+                    os << "UR_IMAGE_INFO_WIDTH";
+                    break;
+                case UR_IMAGE_INFO_HEIGHT:
+                    os << "UR_IMAGE_INFO_HEIGHT";
+                    break;
+                case UR_IMAGE_INFO_DEPTH:
+                    os << "UR_IMAGE_INFO_DEPTH";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_image_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_image_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_IMAGE_INFO_FORMAT: {
+                    const ur_image_format_t *tptr = (const ur_image_format_t *)ptr;
+                    if (sizeof(ur_image_format_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_image_format_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_IMAGE_INFO_ELEMENT_SIZE: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_IMAGE_INFO_ROW_PITCH: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_IMAGE_INFO_SLICE_PITCH: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_IMAGE_INFO_WIDTH: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_IMAGE_INFO_HEIGHT: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_IMAGE_INFO_DEPTH: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
 
-    os << ", ";
-    os << ".pOptions = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_image_format_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, const struct ur_image_format_t params) {
+    os << "(struct ur_image_format_t){";
+    
+        
+    
+        os << ".channelOrder = ";
+        
+        os << 
+            (params.channelOrder)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".channelType = ";
+        
+        os << 
+            (params.channelType)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->ppOptions));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_compile_params_t type
+/// @brief Print operator for the ur_image_desc_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_compile_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".hProgram = ";
-
-    ur::details::printPtr(os,
-                          *(params->phProgram));
-
-    os << ", ";
-    os << ".pOptions = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_image_desc_t params) {
+    os << "(struct ur_image_desc_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".type = ";
+        
+        os << 
+            (params.type)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".width = ";
+        
+        os << 
+            (params.width)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".height = ";
+        
+        os << 
+            (params.height)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".depth = ";
+        
+        os << 
+            (params.depth)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".arraySize = ";
+        
+        os << 
+            (params.arraySize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".rowPitch = ";
+        
+        os << 
+            (params.rowPitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".slicePitch = ";
+        
+        os << 
+            (params.slicePitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numMipLevel = ";
+        
+        os << 
+            (params.numMipLevel)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numSamples = ";
+        
+        os << 
+            (params.numSamples)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->ppOptions));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_compile_exp_params_t type
+/// @brief Print operator for the ur_buffer_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_compile_exp_params_t *params) {
-
-    os << ".hProgram = ";
-
-    ur::details::printPtr(os,
-                          *(params->phProgram));
-
-    os << ", ";
-    os << ".numDevices = ";
-
-    os << *(params->pnumDevices);
+inline std::ostream &operator<<(std::ostream &os, const struct ur_buffer_properties_t params) {
+    os << "(struct ur_buffer_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pHost = ";
+        
+        ur::details::printPtr(os, 
+            (params.pHost)
+        );
 
-    os << ", ";
-    os << ".phDevices = {";
-    for (size_t i = 0; *(params->pphDevices) != NULL && i < *params->pnumDevices; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphDevices))[i]);
-    }
     os << "}";
-
-    os << ", ";
-    os << ".pOptions = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppOptions));
-
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_link_params_t type
+/// @brief Print operator for the ur_buffer_channel_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_link_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".count = ";
-
-    os << *(params->pcount);
+inline std::ostream &operator<<(std::ostream &os, const struct ur_buffer_channel_properties_t params) {
+    os << "(struct ur_buffer_channel_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".channel = ";
+        
+        os << 
+            (params.channel)
+        ;
 
-    os << ", ";
-    os << ".phPrograms = {";
-    for (size_t i = 0; *(params->pphPrograms) != NULL && i < *params->pcount; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphPrograms))[i]);
-    }
     os << "}";
-
-    os << ", ";
-    os << ".pOptions = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppOptions));
-
-    os << ", ";
-    os << ".phProgram = ";
-
-    ur::details::printPtr(os,
-                          *(params->pphProgram));
-
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_link_exp_params_t type
+/// @brief Print operator for the ur_buffer_alloc_location_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_link_exp_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".numDevices = ";
-
-    os << *(params->pnumDevices);
+inline std::ostream &operator<<(std::ostream &os, const struct ur_buffer_alloc_location_properties_t params) {
+    os << "(struct ur_buffer_alloc_location_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".location = ";
+        
+        os << 
+            (params.location)
+        ;
 
-    os << ", ";
-    os << ".phDevices = {";
-    for (size_t i = 0; *(params->pphDevices) != NULL && i < *params->pnumDevices; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphDevices))[i]);
-    }
     os << "}";
+    return os;
+}
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_buffer_region_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, const struct ur_buffer_region_t params) {
+    os << "(struct ur_buffer_region_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".origin = ";
+        
+        os << 
+            (params.origin)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            (params.size)
+        ;
 
-    os << ", ";
-    os << ".count = ";
-
-    os << *(params->pcount);
-
-    os << ", ";
-    os << ".phPrograms = {";
-    for (size_t i = 0; *(params->pphPrograms) != NULL && i < *params->pcount; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphPrograms))[i]);
-    }
     os << "}";
-
-    os << ", ";
-    os << ".pOptions = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppOptions));
-
-    os << ", ";
-    os << ".phProgram = ";
-
-    ur::details::printPtr(os,
-                          *(params->pphProgram));
-
     return os;
 }
-
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_buffer_create_type_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_buffer_create_type_t value) {
+        switch (value) {
+                case UR_BUFFER_CREATE_TYPE_REGION:
+                    os << "UR_BUFFER_CREATE_TYPE_REGION";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_retain_params_t type
+/// @brief Print operator for the ur_mem_native_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_retain_params_t *params) {
-
-    os << ".hProgram = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_mem_native_properties_t params) {
+    os << "(struct ur_mem_native_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".isNativeHandleOwned = ";
+        
+        os << 
+            (params.isNativeHandleOwned)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->phProgram));
 
+    os << "}";
     return os;
 }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_sampler_filter_mode_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_sampler_filter_mode_t value) {
+        switch (value) {
+                case UR_SAMPLER_FILTER_MODE_NEAREST:
+                    os << "UR_SAMPLER_FILTER_MODE_NEAREST";
+                    break;
+                case UR_SAMPLER_FILTER_MODE_LINEAR:
+                    os << "UR_SAMPLER_FILTER_MODE_LINEAR";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_sampler_addressing_mode_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_sampler_addressing_mode_t value) {
+        switch (value) {
+                case UR_SAMPLER_ADDRESSING_MODE_NONE:
+                    os << "UR_SAMPLER_ADDRESSING_MODE_NONE";
+                    break;
+                case UR_SAMPLER_ADDRESSING_MODE_CLAMP_TO_EDGE:
+                    os << "UR_SAMPLER_ADDRESSING_MODE_CLAMP_TO_EDGE";
+                    break;
+                case UR_SAMPLER_ADDRESSING_MODE_CLAMP:
+                    os << "UR_SAMPLER_ADDRESSING_MODE_CLAMP";
+                    break;
+                case UR_SAMPLER_ADDRESSING_MODE_REPEAT:
+                    os << "UR_SAMPLER_ADDRESSING_MODE_REPEAT";
+                    break;
+                case UR_SAMPLER_ADDRESSING_MODE_MIRRORED_REPEAT:
+                    os << "UR_SAMPLER_ADDRESSING_MODE_MIRRORED_REPEAT";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_sampler_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_sampler_info_t value) {
+        switch (value) {
+                case UR_SAMPLER_INFO_REFERENCE_COUNT:
+                    os << "UR_SAMPLER_INFO_REFERENCE_COUNT";
+                    break;
+                case UR_SAMPLER_INFO_CONTEXT:
+                    os << "UR_SAMPLER_INFO_CONTEXT";
+                    break;
+                case UR_SAMPLER_INFO_NORMALIZED_COORDS:
+                    os << "UR_SAMPLER_INFO_NORMALIZED_COORDS";
+                    break;
+                case UR_SAMPLER_INFO_ADDRESSING_MODE:
+                    os << "UR_SAMPLER_INFO_ADDRESSING_MODE";
+                    break;
+                case UR_SAMPLER_INFO_FILTER_MODE:
+                    os << "UR_SAMPLER_INFO_FILTER_MODE";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_sampler_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_sampler_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_SAMPLER_INFO_REFERENCE_COUNT: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_SAMPLER_INFO_CONTEXT: {
+                    const ur_context_handle_t *tptr = (const ur_context_handle_t *)ptr;
+                    if (sizeof(ur_context_handle_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_context_handle_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printPtr(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_SAMPLER_INFO_NORMALIZED_COORDS: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_SAMPLER_INFO_ADDRESSING_MODE: {
+                    const ur_sampler_addressing_mode_t *tptr = (const ur_sampler_addressing_mode_t *)ptr;
+                    if (sizeof(ur_sampler_addressing_mode_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_sampler_addressing_mode_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_SAMPLER_INFO_FILTER_MODE: {
+                    const ur_sampler_filter_mode_t *tptr = (const ur_sampler_filter_mode_t *)ptr;
+                    if (sizeof(ur_sampler_filter_mode_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_sampler_filter_mode_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_release_params_t type
+/// @brief Print operator for the ur_sampler_desc_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_release_params_t *params) {
-
-    os << ".hProgram = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_sampler_desc_t params) {
+    os << "(struct ur_sampler_desc_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".normalizedCoords = ";
+        
+        os << 
+            (params.normalizedCoords)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".addressingMode = ";
+        
+        os << 
+            (params.addressingMode)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".filterMode = ";
+        
+        os << 
+            (params.filterMode)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->phProgram));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_get_function_pointer_params_t type
+/// @brief Print operator for the ur_sampler_native_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_get_function_pointer_params_t *params) {
-
-    os << ".hDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->phDevice));
-
-    os << ", ";
-    os << ".hProgram = ";
-
-    ur::details::printPtr(os,
-                          *(params->phProgram));
-
-    os << ", ";
-    os << ".pFunctionName = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppFunctionName));
-
-    os << ", ";
-    os << ".ppFunctionPointer = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_sampler_native_properties_t params) {
+    os << "(struct ur_sampler_native_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".isNativeHandleOwned = ";
+        
+        os << 
+            (params.isNativeHandleOwned)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->pppFunctionPointer));
 
+    os << "}";
     return os;
 }
-
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_usm_host_mem_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_usm_host_mem_flag_t value) {
+        switch (value) {
+                case UR_USM_HOST_MEM_FLAG_INITIAL_PLACEMENT:
+                    os << "UR_USM_HOST_MEM_FLAG_INITIAL_PLACEMENT";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_usm_host_mem_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_usm_host_mem_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_USM_HOST_MEM_FLAG_INITIAL_PLACEMENT) == (uint32_t)UR_USM_HOST_MEM_FLAG_INITIAL_PLACEMENT) {
+                val ^= (uint32_t)UR_USM_HOST_MEM_FLAG_INITIAL_PLACEMENT;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_HOST_MEM_FLAG_INITIAL_PLACEMENT;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_usm_device_mem_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_usm_device_mem_flag_t value) {
+        switch (value) {
+                case UR_USM_DEVICE_MEM_FLAG_WRITE_COMBINED:
+                    os << "UR_USM_DEVICE_MEM_FLAG_WRITE_COMBINED";
+                    break;
+                case UR_USM_DEVICE_MEM_FLAG_INITIAL_PLACEMENT:
+                    os << "UR_USM_DEVICE_MEM_FLAG_INITIAL_PLACEMENT";
+                    break;
+                case UR_USM_DEVICE_MEM_FLAG_DEVICE_READ_ONLY:
+                    os << "UR_USM_DEVICE_MEM_FLAG_DEVICE_READ_ONLY";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_usm_device_mem_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_usm_device_mem_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_USM_DEVICE_MEM_FLAG_WRITE_COMBINED) == (uint32_t)UR_USM_DEVICE_MEM_FLAG_WRITE_COMBINED) {
+                val ^= (uint32_t)UR_USM_DEVICE_MEM_FLAG_WRITE_COMBINED;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_DEVICE_MEM_FLAG_WRITE_COMBINED;
+            }
+            
+            if ((val & UR_USM_DEVICE_MEM_FLAG_INITIAL_PLACEMENT) == (uint32_t)UR_USM_DEVICE_MEM_FLAG_INITIAL_PLACEMENT) {
+                val ^= (uint32_t)UR_USM_DEVICE_MEM_FLAG_INITIAL_PLACEMENT;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_DEVICE_MEM_FLAG_INITIAL_PLACEMENT;
+            }
+            
+            if ((val & UR_USM_DEVICE_MEM_FLAG_DEVICE_READ_ONLY) == (uint32_t)UR_USM_DEVICE_MEM_FLAG_DEVICE_READ_ONLY) {
+                val ^= (uint32_t)UR_USM_DEVICE_MEM_FLAG_DEVICE_READ_ONLY;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_DEVICE_MEM_FLAG_DEVICE_READ_ONLY;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_usm_pool_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_usm_pool_flag_t value) {
+        switch (value) {
+                case UR_USM_POOL_FLAG_ZERO_INITIALIZE_BLOCK:
+                    os << "UR_USM_POOL_FLAG_ZERO_INITIALIZE_BLOCK";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_usm_pool_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_usm_pool_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_USM_POOL_FLAG_ZERO_INITIALIZE_BLOCK) == (uint32_t)UR_USM_POOL_FLAG_ZERO_INITIALIZE_BLOCK) {
+                val ^= (uint32_t)UR_USM_POOL_FLAG_ZERO_INITIALIZE_BLOCK;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_POOL_FLAG_ZERO_INITIALIZE_BLOCK;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_usm_type_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_usm_type_t value) {
+        switch (value) {
+                case UR_USM_TYPE_UNKNOWN:
+                    os << "UR_USM_TYPE_UNKNOWN";
+                    break;
+                case UR_USM_TYPE_HOST:
+                    os << "UR_USM_TYPE_HOST";
+                    break;
+                case UR_USM_TYPE_DEVICE:
+                    os << "UR_USM_TYPE_DEVICE";
+                    break;
+                case UR_USM_TYPE_SHARED:
+                    os << "UR_USM_TYPE_SHARED";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_usm_alloc_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_usm_alloc_info_t value) {
+        switch (value) {
+                case UR_USM_ALLOC_INFO_TYPE:
+                    os << "UR_USM_ALLOC_INFO_TYPE";
+                    break;
+                case UR_USM_ALLOC_INFO_BASE_PTR:
+                    os << "UR_USM_ALLOC_INFO_BASE_PTR";
+                    break;
+                case UR_USM_ALLOC_INFO_SIZE:
+                    os << "UR_USM_ALLOC_INFO_SIZE";
+                    break;
+                case UR_USM_ALLOC_INFO_DEVICE:
+                    os << "UR_USM_ALLOC_INFO_DEVICE";
+                    break;
+                case UR_USM_ALLOC_INFO_POOL:
+                    os << "UR_USM_ALLOC_INFO_POOL";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_usm_alloc_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_usm_alloc_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_USM_ALLOC_INFO_TYPE: {
+                    const ur_usm_type_t *tptr = (const ur_usm_type_t *)ptr;
+                    if (sizeof(ur_usm_type_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_usm_type_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_USM_ALLOC_INFO_BASE_PTR: {
+                    const void * const *tptr = (const void * const *)ptr;
+                    if (sizeof(void *) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(void *) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_USM_ALLOC_INFO_SIZE: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_USM_ALLOC_INFO_DEVICE: {
+                    const ur_device_handle_t *tptr = (const ur_device_handle_t *)ptr;
+                    if (sizeof(ur_device_handle_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_handle_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printPtr(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_USM_ALLOC_INFO_POOL: {
+                    const ur_usm_pool_handle_t *tptr = (const ur_usm_pool_handle_t *)ptr;
+                    if (sizeof(ur_usm_pool_handle_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_usm_pool_handle_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printPtr(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_usm_advice_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_usm_advice_flag_t value) {
+        switch (value) {
+                case UR_USM_ADVICE_FLAG_DEFAULT:
+                    os << "UR_USM_ADVICE_FLAG_DEFAULT";
+                    break;
+                case UR_USM_ADVICE_FLAG_SET_READ_MOSTLY:
+                    os << "UR_USM_ADVICE_FLAG_SET_READ_MOSTLY";
+                    break;
+                case UR_USM_ADVICE_FLAG_CLEAR_READ_MOSTLY:
+                    os << "UR_USM_ADVICE_FLAG_CLEAR_READ_MOSTLY";
+                    break;
+                case UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION:
+                    os << "UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION";
+                    break;
+                case UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION:
+                    os << "UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION";
+                    break;
+                case UR_USM_ADVICE_FLAG_SET_NON_ATOMIC_MOSTLY:
+                    os << "UR_USM_ADVICE_FLAG_SET_NON_ATOMIC_MOSTLY";
+                    break;
+                case UR_USM_ADVICE_FLAG_CLEAR_NON_ATOMIC_MOSTLY:
+                    os << "UR_USM_ADVICE_FLAG_CLEAR_NON_ATOMIC_MOSTLY";
+                    break;
+                case UR_USM_ADVICE_FLAG_BIAS_CACHED:
+                    os << "UR_USM_ADVICE_FLAG_BIAS_CACHED";
+                    break;
+                case UR_USM_ADVICE_FLAG_BIAS_UNCACHED:
+                    os << "UR_USM_ADVICE_FLAG_BIAS_UNCACHED";
+                    break;
+                case UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_DEVICE:
+                    os << "UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_DEVICE";
+                    break;
+                case UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_DEVICE:
+                    os << "UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_DEVICE";
+                    break;
+                case UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_HOST:
+                    os << "UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_HOST";
+                    break;
+                case UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_HOST:
+                    os << "UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_HOST";
+                    break;
+                case UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION_HOST:
+                    os << "UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION_HOST";
+                    break;
+                case UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION_HOST:
+                    os << "UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION_HOST";
+                    break;
+                case UR_USM_ADVICE_FLAG_SET_NON_COHERENT_MEMORY:
+                    os << "UR_USM_ADVICE_FLAG_SET_NON_COHERENT_MEMORY";
+                    break;
+                case UR_USM_ADVICE_FLAG_CLEAR_NON_COHERENT_MEMORY:
+                    os << "UR_USM_ADVICE_FLAG_CLEAR_NON_COHERENT_MEMORY";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_usm_advice_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_usm_advice_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_USM_ADVICE_FLAG_DEFAULT) == (uint32_t)UR_USM_ADVICE_FLAG_DEFAULT) {
+                val ^= (uint32_t)UR_USM_ADVICE_FLAG_DEFAULT;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_ADVICE_FLAG_DEFAULT;
+            }
+            
+            if ((val & UR_USM_ADVICE_FLAG_SET_READ_MOSTLY) == (uint32_t)UR_USM_ADVICE_FLAG_SET_READ_MOSTLY) {
+                val ^= (uint32_t)UR_USM_ADVICE_FLAG_SET_READ_MOSTLY;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_ADVICE_FLAG_SET_READ_MOSTLY;
+            }
+            
+            if ((val & UR_USM_ADVICE_FLAG_CLEAR_READ_MOSTLY) == (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_READ_MOSTLY) {
+                val ^= (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_READ_MOSTLY;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_ADVICE_FLAG_CLEAR_READ_MOSTLY;
+            }
+            
+            if ((val & UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION) == (uint32_t)UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION) {
+                val ^= (uint32_t)UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION;
+            }
+            
+            if ((val & UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION) == (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION) {
+                val ^= (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION;
+            }
+            
+            if ((val & UR_USM_ADVICE_FLAG_SET_NON_ATOMIC_MOSTLY) == (uint32_t)UR_USM_ADVICE_FLAG_SET_NON_ATOMIC_MOSTLY) {
+                val ^= (uint32_t)UR_USM_ADVICE_FLAG_SET_NON_ATOMIC_MOSTLY;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_ADVICE_FLAG_SET_NON_ATOMIC_MOSTLY;
+            }
+            
+            if ((val & UR_USM_ADVICE_FLAG_CLEAR_NON_ATOMIC_MOSTLY) == (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_NON_ATOMIC_MOSTLY) {
+                val ^= (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_NON_ATOMIC_MOSTLY;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_ADVICE_FLAG_CLEAR_NON_ATOMIC_MOSTLY;
+            }
+            
+            if ((val & UR_USM_ADVICE_FLAG_BIAS_CACHED) == (uint32_t)UR_USM_ADVICE_FLAG_BIAS_CACHED) {
+                val ^= (uint32_t)UR_USM_ADVICE_FLAG_BIAS_CACHED;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_ADVICE_FLAG_BIAS_CACHED;
+            }
+            
+            if ((val & UR_USM_ADVICE_FLAG_BIAS_UNCACHED) == (uint32_t)UR_USM_ADVICE_FLAG_BIAS_UNCACHED) {
+                val ^= (uint32_t)UR_USM_ADVICE_FLAG_BIAS_UNCACHED;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_ADVICE_FLAG_BIAS_UNCACHED;
+            }
+            
+            if ((val & UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_DEVICE) == (uint32_t)UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_DEVICE) {
+                val ^= (uint32_t)UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_DEVICE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_DEVICE;
+            }
+            
+            if ((val & UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_DEVICE) == (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_DEVICE) {
+                val ^= (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_DEVICE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_DEVICE;
+            }
+            
+            if ((val & UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_HOST) == (uint32_t)UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_HOST) {
+                val ^= (uint32_t)UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_HOST;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_ADVICE_FLAG_SET_ACCESSED_BY_HOST;
+            }
+            
+            if ((val & UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_HOST) == (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_HOST) {
+                val ^= (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_HOST;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_ADVICE_FLAG_CLEAR_ACCESSED_BY_HOST;
+            }
+            
+            if ((val & UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION_HOST) == (uint32_t)UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION_HOST) {
+                val ^= (uint32_t)UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION_HOST;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_ADVICE_FLAG_SET_PREFERRED_LOCATION_HOST;
+            }
+            
+            if ((val & UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION_HOST) == (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION_HOST) {
+                val ^= (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION_HOST;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_ADVICE_FLAG_CLEAR_PREFERRED_LOCATION_HOST;
+            }
+            
+            if ((val & UR_USM_ADVICE_FLAG_SET_NON_COHERENT_MEMORY) == (uint32_t)UR_USM_ADVICE_FLAG_SET_NON_COHERENT_MEMORY) {
+                val ^= (uint32_t)UR_USM_ADVICE_FLAG_SET_NON_COHERENT_MEMORY;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_ADVICE_FLAG_SET_NON_COHERENT_MEMORY;
+            }
+            
+            if ((val & UR_USM_ADVICE_FLAG_CLEAR_NON_COHERENT_MEMORY) == (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_NON_COHERENT_MEMORY) {
+                val ^= (uint32_t)UR_USM_ADVICE_FLAG_CLEAR_NON_COHERENT_MEMORY;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_ADVICE_FLAG_CLEAR_NON_COHERENT_MEMORY;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_get_global_variable_pointer_params_t type
+/// @brief Print operator for the ur_usm_desc_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_get_global_variable_pointer_params_t *params) {
-
-    os << ".hDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->phDevice));
-
-    os << ", ";
-    os << ".hProgram = ";
-
-    ur::details::printPtr(os,
-                          *(params->phProgram));
-
-    os << ", ";
-    os << ".pGlobalVariableName = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppGlobalVariableName));
-
-    os << ", ";
-    os << ".pGlobalVariableSizeRet = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppGlobalVariableSizeRet));
-
-    os << ", ";
-    os << ".ppGlobalVariablePointerRet = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_usm_desc_t params) {
+    os << "(struct ur_usm_desc_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hints = ";
+        
+        ur::details::printFlag<ur_usm_advice_flag_t>(os, 
+            (params.hints)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".align = ";
+        
+        os << 
+            (params.align)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->pppGlobalVariablePointerRet));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_get_info_params_t type
+/// @brief Print operator for the ur_usm_host_desc_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_get_info_params_t *params) {
-
-    os << ".hProgram = ";
-
-    ur::details::printPtr(os,
-                          *(params->phProgram));
-
-    os << ", ";
-    os << ".propName = ";
-
-    os << *(params->ppropName);
-
-    os << ", ";
-    os << ".propSize = ";
-
-    os << *(params->ppropSize);
-
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
-
-    os << ", ";
-    os << ".pPropSizeRet = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_usm_host_desc_t params) {
+    os << "(struct ur_usm_host_desc_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".flags = ";
+        
+        ur::details::printFlag<ur_usm_host_mem_flag_t>(os, 
+            (params.flags)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_get_build_info_params_t type
+/// @brief Print operator for the ur_usm_device_desc_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_get_build_info_params_t *params) {
-
-    os << ".hProgram = ";
-
-    ur::details::printPtr(os,
-                          *(params->phProgram));
-
-    os << ", ";
-    os << ".hDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->phDevice));
-
-    os << ", ";
-    os << ".propName = ";
-
-    os << *(params->ppropName);
-
-    os << ", ";
-    os << ".propSize = ";
-
-    os << *(params->ppropSize);
-
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
-
-    os << ", ";
-    os << ".pPropSizeRet = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_usm_device_desc_t params) {
+    os << "(struct ur_usm_device_desc_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".flags = ";
+        
+        ur::details::printFlag<ur_usm_device_mem_flag_t>(os, 
+            (params.flags)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_set_specialization_constants_params_t type
+/// @brief Print operator for the ur_usm_alloc_location_desc_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_set_specialization_constants_params_t *params) {
-
-    os << ".hProgram = ";
-
-    ur::details::printPtr(os,
-                          *(params->phProgram));
-
-    os << ", ";
-    os << ".count = ";
-
-    os << *(params->pcount);
+inline std::ostream &operator<<(std::ostream &os, const struct ur_usm_alloc_location_desc_t params) {
+    os << "(struct ur_usm_alloc_location_desc_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".location = ";
+        
+        os << 
+            (params.location)
+        ;
 
-    os << ", ";
-    os << ".pSpecConstants = {";
-    for (size_t i = 0; *(params->ppSpecConstants) != NULL && i < *params->pcount; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        os << (*(params->ppSpecConstants))[i];
-    }
     os << "}";
-
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_get_native_handle_params_t type
+/// @brief Print operator for the ur_usm_pool_desc_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_get_native_handle_params_t *params) {
-
-    os << ".hProgram = ";
-
-    ur::details::printPtr(os,
-                          *(params->phProgram));
-
-    os << ", ";
-    os << ".phNativeProgram = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_usm_pool_desc_t params) {
+    os << "(struct ur_usm_pool_desc_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".flags = ";
+        
+        ur::details::printFlag<ur_usm_pool_flag_t>(os, 
+            (params.flags)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphNativeProgram));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_program_create_with_native_handle_params_t type
+/// @brief Print operator for the ur_usm_pool_limits_desc_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_create_with_native_handle_params_t *params) {
-
-    os << ".hNativeProgram = ";
-
-    ur::details::printPtr(os, reinterpret_cast<void *>(
-                                  *(params->phNativeProgram)));
-
-    os << ", ";
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".pProperties = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
-
-    os << ", ";
-    os << ".phProgram = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_usm_pool_limits_desc_t params) {
+    os << "(struct ur_usm_pool_limits_desc_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".maxPoolableSize = ";
+        
+        os << 
+            (params.maxPoolableSize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".minDriverAllocSize = ";
+        
+        os << 
+            (params.minDriverAllocSize)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->pphProgram));
 
+    os << "}";
     return os;
 }
-
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_usm_pool_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_usm_pool_info_t value) {
+        switch (value) {
+                case UR_USM_POOL_INFO_REFERENCE_COUNT:
+                    os << "UR_USM_POOL_INFO_REFERENCE_COUNT";
+                    break;
+                case UR_USM_POOL_INFO_CONTEXT:
+                    os << "UR_USM_POOL_INFO_CONTEXT";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_usm_pool_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_usm_pool_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_USM_POOL_INFO_REFERENCE_COUNT: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_USM_POOL_INFO_CONTEXT: {
+                    const ur_context_handle_t *tptr = (const ur_context_handle_t *)ptr;
+                    if (sizeof(ur_context_handle_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_context_handle_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printPtr(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_virtual_mem_granularity_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_virtual_mem_granularity_info_t value) {
+        switch (value) {
+                case UR_VIRTUAL_MEM_GRANULARITY_INFO_MINIMUM:
+                    os << "UR_VIRTUAL_MEM_GRANULARITY_INFO_MINIMUM";
+                    break;
+                case UR_VIRTUAL_MEM_GRANULARITY_INFO_RECOMMENDED:
+                    os << "UR_VIRTUAL_MEM_GRANULARITY_INFO_RECOMMENDED";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_virtual_mem_granularity_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_virtual_mem_granularity_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_VIRTUAL_MEM_GRANULARITY_INFO_MINIMUM: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_VIRTUAL_MEM_GRANULARITY_INFO_RECOMMENDED: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_virtual_mem_access_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_virtual_mem_access_flag_t value) {
+        switch (value) {
+                case UR_VIRTUAL_MEM_ACCESS_FLAG_NONE:
+                    os << "UR_VIRTUAL_MEM_ACCESS_FLAG_NONE";
+                    break;
+                case UR_VIRTUAL_MEM_ACCESS_FLAG_READ_WRITE:
+                    os << "UR_VIRTUAL_MEM_ACCESS_FLAG_READ_WRITE";
+                    break;
+                case UR_VIRTUAL_MEM_ACCESS_FLAG_READ_ONLY:
+                    os << "UR_VIRTUAL_MEM_ACCESS_FLAG_READ_ONLY";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_virtual_mem_access_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_virtual_mem_access_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_VIRTUAL_MEM_ACCESS_FLAG_NONE) == (uint32_t)UR_VIRTUAL_MEM_ACCESS_FLAG_NONE) {
+                val ^= (uint32_t)UR_VIRTUAL_MEM_ACCESS_FLAG_NONE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_VIRTUAL_MEM_ACCESS_FLAG_NONE;
+            }
+            
+            if ((val & UR_VIRTUAL_MEM_ACCESS_FLAG_READ_WRITE) == (uint32_t)UR_VIRTUAL_MEM_ACCESS_FLAG_READ_WRITE) {
+                val ^= (uint32_t)UR_VIRTUAL_MEM_ACCESS_FLAG_READ_WRITE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_VIRTUAL_MEM_ACCESS_FLAG_READ_WRITE;
+            }
+            
+            if ((val & UR_VIRTUAL_MEM_ACCESS_FLAG_READ_ONLY) == (uint32_t)UR_VIRTUAL_MEM_ACCESS_FLAG_READ_ONLY) {
+                val ^= (uint32_t)UR_VIRTUAL_MEM_ACCESS_FLAG_READ_ONLY;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_VIRTUAL_MEM_ACCESS_FLAG_READ_ONLY;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_virtual_mem_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_virtual_mem_info_t value) {
+        switch (value) {
+                case UR_VIRTUAL_MEM_INFO_ACCESS_MODE:
+                    os << "UR_VIRTUAL_MEM_INFO_ACCESS_MODE";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_virtual_mem_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_virtual_mem_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_VIRTUAL_MEM_INFO_ACCESS_MODE: {
+                    const ur_virtual_mem_access_flags_t *tptr = (const ur_virtual_mem_access_flags_t *)ptr;
+                    if (sizeof(ur_virtual_mem_access_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_virtual_mem_access_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_virtual_mem_access_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_physical_mem_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_physical_mem_flag_t value) {
+        switch (value) {
+                case UR_PHYSICAL_MEM_FLAG_TBD:
+                    os << "UR_PHYSICAL_MEM_FLAG_TBD";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_physical_mem_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_physical_mem_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_PHYSICAL_MEM_FLAG_TBD) == (uint32_t)UR_PHYSICAL_MEM_FLAG_TBD) {
+                val ^= (uint32_t)UR_PHYSICAL_MEM_FLAG_TBD;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_PHYSICAL_MEM_FLAG_TBD;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_create_params_t type
+/// @brief Print operator for the ur_physical_mem_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_create_params_t *params) {
-
-    os << ".hProgram = ";
-
-    ur::details::printPtr(os,
-                          *(params->phProgram));
-
-    os << ", ";
-    os << ".pKernelName = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppKernelName));
-
-    os << ", ";
-    os << ".phKernel = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_physical_mem_properties_t params) {
+    os << "(struct ur_physical_mem_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".flags = ";
+        
+        ur::details::printFlag<ur_physical_mem_flag_t>(os, 
+            (params.flags)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphKernel));
 
+    os << "}";
     return os;
 }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_program_metadata_type_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_program_metadata_type_t value) {
+        switch (value) {
+                case UR_PROGRAM_METADATA_TYPE_UINT32:
+                    os << "UR_PROGRAM_METADATA_TYPE_UINT32";
+                    break;
+                case UR_PROGRAM_METADATA_TYPE_UINT64:
+                    os << "UR_PROGRAM_METADATA_TYPE_UINT64";
+                    break;
+                case UR_PROGRAM_METADATA_TYPE_BYTE_ARRAY:
+                    os << "UR_PROGRAM_METADATA_TYPE_BYTE_ARRAY";
+                    break;
+                case UR_PROGRAM_METADATA_TYPE_STRING:
+                    os << "UR_PROGRAM_METADATA_TYPE_STRING";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+namespace ur::details {
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_get_info_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_get_info_params_t *params) {
+    ///////////////////////////////////////////////////////////////////////////////
+    // @brief Print ur_program_metadata_value_t union
+    inline ur_result_t printUnion(
+    std::ostream &os,
+    const union ur_program_metadata_value_t params,
+    const enum ur_program_metadata_type_t tag
+){
+    os << "(union ur_program_metadata_value_t){";
 
-    os << ".hKernel = ";
+    switch(tag){
+    case UR_PROGRAM_METADATA_TYPE_UINT32:
+        
+    
+        os << ".data32 = ";
+        
+        os << 
+            (params.data32)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->phKernel));
 
-    os << ", ";
-    os << ".propName = ";
+        break;
+    case UR_PROGRAM_METADATA_TYPE_UINT64:
+        
+    
+        os << ".data64 = ";
+        
+        os << 
+            (params.data64)
+        ;
 
-    os << *(params->ppropName);
 
-    os << ", ";
-    os << ".propSize = ";
+        break;
+    case UR_PROGRAM_METADATA_TYPE_STRING:
+        
+    
+        os << ".pString = ";
+        
+        ur::details::printPtr(os, 
+            (params.pString)
+        );
 
-    os << *(params->ppropSize);
 
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
+        break;
+    case UR_PROGRAM_METADATA_TYPE_BYTE_ARRAY:
+        
+    
+        os << ".pData = ";
+        
+        ur::details::printPtr(os, 
+            (params.pData)
+        );
 
-    os << ", ";
-    os << ".pPropSizeRet = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
+        break;
+    default:
+        os << "<unknown>";
+        return UR_RESULT_ERROR_INVALID_ENUMERATION;
+    }
+    os << "}";
+    return UR_RESULT_SUCCESS;
+}
+} // namespace ur::details
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_program_metadata_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, const struct ur_program_metadata_t params) {
+    os << "(struct ur_program_metadata_t){";
+    
+        
+    
+        os << ".pName = ";
+        
+        ur::details::printPtr(os, 
+            (params.pName)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".type = ";
+        
+        os << 
+            (params.type)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            (params.size)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".value = ";
+        ur::details::printUnion(os, (params.value), params.type);
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_get_group_info_params_t type
+/// @brief Print operator for the ur_program_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_get_group_info_params_t *params) {
-
-    os << ".hKernel = ";
-
-    ur::details::printPtr(os,
-                          *(params->phKernel));
-
-    os << ", ";
-    os << ".hDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->phDevice));
-
-    os << ", ";
-    os << ".propName = ";
-
-    os << *(params->ppropName);
-
-    os << ", ";
-    os << ".propSize = ";
-
-    os << *(params->ppropSize);
+inline std::ostream &operator<<(std::ostream &os, const struct ur_program_properties_t params) {
+    os << "(struct ur_program_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".count = ";
+        
+        os << 
+            (params.count)
+        ;
 
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".pPropSizeRet = ";
+        
+    
+        os << ", ";
+        os << ".pMetadatas = {";
+        for (size_t i = 0; (params.pMetadatas) != NULL && i < params.count; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        os << 
+                ((params.pMetadatas))[i]
+            ;
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
+        }
+        os << "}";
 
+    os << "}";
     return os;
 }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_program_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_program_info_t value) {
+        switch (value) {
+                case UR_PROGRAM_INFO_REFERENCE_COUNT:
+                    os << "UR_PROGRAM_INFO_REFERENCE_COUNT";
+                    break;
+                case UR_PROGRAM_INFO_CONTEXT:
+                    os << "UR_PROGRAM_INFO_CONTEXT";
+                    break;
+                case UR_PROGRAM_INFO_NUM_DEVICES:
+                    os << "UR_PROGRAM_INFO_NUM_DEVICES";
+                    break;
+                case UR_PROGRAM_INFO_DEVICES:
+                    os << "UR_PROGRAM_INFO_DEVICES";
+                    break;
+                case UR_PROGRAM_INFO_IL:
+                    os << "UR_PROGRAM_INFO_IL";
+                    break;
+                case UR_PROGRAM_INFO_BINARY_SIZES:
+                    os << "UR_PROGRAM_INFO_BINARY_SIZES";
+                    break;
+                case UR_PROGRAM_INFO_BINARIES:
+                    os << "UR_PROGRAM_INFO_BINARIES";
+                    break;
+                case UR_PROGRAM_INFO_NUM_KERNELS:
+                    os << "UR_PROGRAM_INFO_NUM_KERNELS";
+                    break;
+                case UR_PROGRAM_INFO_KERNEL_NAMES:
+                    os << "UR_PROGRAM_INFO_KERNEL_NAMES";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_program_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_program_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_PROGRAM_INFO_REFERENCE_COUNT: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_PROGRAM_INFO_CONTEXT: {
+                    const ur_context_handle_t *tptr = (const ur_context_handle_t *)ptr;
+                    if (sizeof(ur_context_handle_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_context_handle_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printPtr(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_PROGRAM_INFO_NUM_DEVICES: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_PROGRAM_INFO_DEVICES: {
+                    
+                    const ur_device_handle_t *tptr = (const ur_device_handle_t *)ptr;
+                            os << "{";
+                            size_t nelems = size / sizeof(ur_device_handle_t);
+                            for (size_t i = 0; i < nelems; ++i) {
+                                if (i != 0) {
+                                    os << ", ";
+                                }
+                                
+        ur::details::printPtr(os, 
+                                    tptr[i]
+                                );
+
+                            }
+                            os << "}";
+                } break;
+                case UR_PROGRAM_INFO_IL: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_PROGRAM_INFO_BINARY_SIZES: {
+                    
+                    const size_t *tptr = (const size_t *)ptr;
+                            os << "{";
+                            size_t nelems = size / sizeof(size_t);
+                            for (size_t i = 0; i < nelems; ++i) {
+                                if (i != 0) {
+                                    os << ", ";
+                                }
+                                
+        os << 
+                                    tptr[i]
+                                ;
+
+                            }
+                            os << "}";
+                } break;
+                case UR_PROGRAM_INFO_BINARIES: {
+                    
+                    const unsigned char *tptr = (const unsigned char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_PROGRAM_INFO_NUM_KERNELS: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_PROGRAM_INFO_KERNEL_NAMES: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_program_build_status_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_program_build_status_t value) {
+        switch (value) {
+                case UR_PROGRAM_BUILD_STATUS_NONE:
+                    os << "UR_PROGRAM_BUILD_STATUS_NONE";
+                    break;
+                case UR_PROGRAM_BUILD_STATUS_ERROR:
+                    os << "UR_PROGRAM_BUILD_STATUS_ERROR";
+                    break;
+                case UR_PROGRAM_BUILD_STATUS_SUCCESS:
+                    os << "UR_PROGRAM_BUILD_STATUS_SUCCESS";
+                    break;
+                case UR_PROGRAM_BUILD_STATUS_IN_PROGRESS:
+                    os << "UR_PROGRAM_BUILD_STATUS_IN_PROGRESS";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_program_binary_type_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_program_binary_type_t value) {
+        switch (value) {
+                case UR_PROGRAM_BINARY_TYPE_NONE:
+                    os << "UR_PROGRAM_BINARY_TYPE_NONE";
+                    break;
+                case UR_PROGRAM_BINARY_TYPE_COMPILED_OBJECT:
+                    os << "UR_PROGRAM_BINARY_TYPE_COMPILED_OBJECT";
+                    break;
+                case UR_PROGRAM_BINARY_TYPE_LIBRARY:
+                    os << "UR_PROGRAM_BINARY_TYPE_LIBRARY";
+                    break;
+                case UR_PROGRAM_BINARY_TYPE_EXECUTABLE:
+                    os << "UR_PROGRAM_BINARY_TYPE_EXECUTABLE";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_program_build_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_program_build_info_t value) {
+        switch (value) {
+                case UR_PROGRAM_BUILD_INFO_STATUS:
+                    os << "UR_PROGRAM_BUILD_INFO_STATUS";
+                    break;
+                case UR_PROGRAM_BUILD_INFO_OPTIONS:
+                    os << "UR_PROGRAM_BUILD_INFO_OPTIONS";
+                    break;
+                case UR_PROGRAM_BUILD_INFO_LOG:
+                    os << "UR_PROGRAM_BUILD_INFO_LOG";
+                    break;
+                case UR_PROGRAM_BUILD_INFO_BINARY_TYPE:
+                    os << "UR_PROGRAM_BUILD_INFO_BINARY_TYPE";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_program_build_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_program_build_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_PROGRAM_BUILD_INFO_STATUS: {
+                    const ur_program_build_status_t *tptr = (const ur_program_build_status_t *)ptr;
+                    if (sizeof(ur_program_build_status_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_program_build_status_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_PROGRAM_BUILD_INFO_OPTIONS: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_PROGRAM_BUILD_INFO_LOG: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_PROGRAM_BUILD_INFO_BINARY_TYPE: {
+                    const ur_program_binary_type_t *tptr = (const ur_program_binary_type_t *)ptr;
+                    if (sizeof(ur_program_binary_type_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_program_binary_type_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_get_sub_group_info_params_t type
+/// @brief Print operator for the ur_specialization_constant_info_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_get_sub_group_info_params_t *params) {
-
-    os << ".hKernel = ";
-
-    ur::details::printPtr(os,
-                          *(params->phKernel));
-
-    os << ", ";
-    os << ".hDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->phDevice));
-
-    os << ", ";
-    os << ".propName = ";
-
-    os << *(params->ppropName);
-
-    os << ", ";
-    os << ".propSize = ";
-
-    os << *(params->ppropSize);
-
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
-
-    os << ", ";
-    os << ".pPropSizeRet = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_specialization_constant_info_t params) {
+    os << "(struct ur_specialization_constant_info_t){";
+    
+        
+    
+        os << ".id = ";
+        
+        os << 
+            (params.id)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            (params.size)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pValue = ";
+        
+        ur::details::printPtr(os, 
+            (params.pValue)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_retain_params_t type
+/// @brief Print operator for the ur_program_native_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_retain_params_t *params) {
-
-    os << ".hKernel = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_program_native_properties_t params) {
+    os << "(struct ur_program_native_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".isNativeHandleOwned = ";
+        
+        os << 
+            (params.isNativeHandleOwned)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->phKernel));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_release_params_t type
+/// @brief Print operator for the ur_kernel_arg_value_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_release_params_t *params) {
-
-    os << ".hKernel = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_kernel_arg_value_properties_t params) {
+    os << "(struct ur_kernel_arg_value_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phKernel));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_get_native_handle_params_t type
+/// @brief Print operator for the ur_kernel_arg_local_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_get_native_handle_params_t *params) {
-
-    os << ".hKernel = ";
-
-    ur::details::printPtr(os,
-                          *(params->phKernel));
-
-    os << ", ";
-    os << ".phNativeKernel = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_kernel_arg_local_properties_t params) {
+    os << "(struct ur_kernel_arg_local_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphNativeKernel));
 
+    os << "}";
     return os;
 }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_kernel_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_kernel_info_t value) {
+        switch (value) {
+                case UR_KERNEL_INFO_FUNCTION_NAME:
+                    os << "UR_KERNEL_INFO_FUNCTION_NAME";
+                    break;
+                case UR_KERNEL_INFO_NUM_ARGS:
+                    os << "UR_KERNEL_INFO_NUM_ARGS";
+                    break;
+                case UR_KERNEL_INFO_REFERENCE_COUNT:
+                    os << "UR_KERNEL_INFO_REFERENCE_COUNT";
+                    break;
+                case UR_KERNEL_INFO_CONTEXT:
+                    os << "UR_KERNEL_INFO_CONTEXT";
+                    break;
+                case UR_KERNEL_INFO_PROGRAM:
+                    os << "UR_KERNEL_INFO_PROGRAM";
+                    break;
+                case UR_KERNEL_INFO_ATTRIBUTES:
+                    os << "UR_KERNEL_INFO_ATTRIBUTES";
+                    break;
+                case UR_KERNEL_INFO_NUM_REGS:
+                    os << "UR_KERNEL_INFO_NUM_REGS";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_kernel_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_kernel_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_KERNEL_INFO_FUNCTION_NAME: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_KERNEL_INFO_NUM_ARGS: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_KERNEL_INFO_REFERENCE_COUNT: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_KERNEL_INFO_CONTEXT: {
+                    const ur_context_handle_t *tptr = (const ur_context_handle_t *)ptr;
+                    if (sizeof(ur_context_handle_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_context_handle_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printPtr(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_KERNEL_INFO_PROGRAM: {
+                    const ur_program_handle_t *tptr = (const ur_program_handle_t *)ptr;
+                    if (sizeof(ur_program_handle_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_program_handle_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printPtr(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_KERNEL_INFO_ATTRIBUTES: {
+                    
+                    const char *tptr = (const char *)ptr;
+                            printPtr(os, tptr);
+                } break;
+                case UR_KERNEL_INFO_NUM_REGS: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_kernel_group_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_kernel_group_info_t value) {
+        switch (value) {
+                case UR_KERNEL_GROUP_INFO_GLOBAL_WORK_SIZE:
+                    os << "UR_KERNEL_GROUP_INFO_GLOBAL_WORK_SIZE";
+                    break;
+                case UR_KERNEL_GROUP_INFO_WORK_GROUP_SIZE:
+                    os << "UR_KERNEL_GROUP_INFO_WORK_GROUP_SIZE";
+                    break;
+                case UR_KERNEL_GROUP_INFO_COMPILE_WORK_GROUP_SIZE:
+                    os << "UR_KERNEL_GROUP_INFO_COMPILE_WORK_GROUP_SIZE";
+                    break;
+                case UR_KERNEL_GROUP_INFO_LOCAL_MEM_SIZE:
+                    os << "UR_KERNEL_GROUP_INFO_LOCAL_MEM_SIZE";
+                    break;
+                case UR_KERNEL_GROUP_INFO_PREFERRED_WORK_GROUP_SIZE_MULTIPLE:
+                    os << "UR_KERNEL_GROUP_INFO_PREFERRED_WORK_GROUP_SIZE_MULTIPLE";
+                    break;
+                case UR_KERNEL_GROUP_INFO_PRIVATE_MEM_SIZE:
+                    os << "UR_KERNEL_GROUP_INFO_PRIVATE_MEM_SIZE";
+                    break;
+                case UR_KERNEL_GROUP_INFO_COMPILE_MAX_WORK_GROUP_SIZE:
+                    os << "UR_KERNEL_GROUP_INFO_COMPILE_MAX_WORK_GROUP_SIZE";
+                    break;
+                case UR_KERNEL_GROUP_INFO_COMPILE_MAX_LINEAR_WORK_GROUP_SIZE:
+                    os << "UR_KERNEL_GROUP_INFO_COMPILE_MAX_LINEAR_WORK_GROUP_SIZE";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_kernel_group_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_kernel_group_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_KERNEL_GROUP_INFO_GLOBAL_WORK_SIZE: {
+                    
+                    const size_t *tptr = (const size_t *)ptr;
+                            os << "{";
+                            size_t nelems = size / sizeof(size_t);
+                            for (size_t i = 0; i < nelems; ++i) {
+                                if (i != 0) {
+                                    os << ", ";
+                                }
+                                
+        os << 
+                                    tptr[i]
+                                ;
+
+                            }
+                            os << "}";
+                } break;
+                case UR_KERNEL_GROUP_INFO_WORK_GROUP_SIZE: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_KERNEL_GROUP_INFO_COMPILE_WORK_GROUP_SIZE: {
+                    
+                    const size_t *tptr = (const size_t *)ptr;
+                            os << "{";
+                            size_t nelems = size / sizeof(size_t);
+                            for (size_t i = 0; i < nelems; ++i) {
+                                if (i != 0) {
+                                    os << ", ";
+                                }
+                                
+        os << 
+                                    tptr[i]
+                                ;
+
+                            }
+                            os << "}";
+                } break;
+                case UR_KERNEL_GROUP_INFO_LOCAL_MEM_SIZE: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_KERNEL_GROUP_INFO_PREFERRED_WORK_GROUP_SIZE_MULTIPLE: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_KERNEL_GROUP_INFO_PRIVATE_MEM_SIZE: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_KERNEL_GROUP_INFO_COMPILE_MAX_WORK_GROUP_SIZE: {
+                    
+                    const size_t *tptr = (const size_t *)ptr;
+                            os << "{";
+                            size_t nelems = size / sizeof(size_t);
+                            for (size_t i = 0; i < nelems; ++i) {
+                                if (i != 0) {
+                                    os << ", ";
+                                }
+                                
+        os << 
+                                    tptr[i]
+                                ;
+
+                            }
+                            os << "}";
+                } break;
+                case UR_KERNEL_GROUP_INFO_COMPILE_MAX_LINEAR_WORK_GROUP_SIZE: {
+                    const size_t *tptr = (const size_t *)ptr;
+                    if (sizeof(size_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(size_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_kernel_sub_group_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_kernel_sub_group_info_t value) {
+        switch (value) {
+                case UR_KERNEL_SUB_GROUP_INFO_MAX_SUB_GROUP_SIZE:
+                    os << "UR_KERNEL_SUB_GROUP_INFO_MAX_SUB_GROUP_SIZE";
+                    break;
+                case UR_KERNEL_SUB_GROUP_INFO_MAX_NUM_SUB_GROUPS:
+                    os << "UR_KERNEL_SUB_GROUP_INFO_MAX_NUM_SUB_GROUPS";
+                    break;
+                case UR_KERNEL_SUB_GROUP_INFO_COMPILE_NUM_SUB_GROUPS:
+                    os << "UR_KERNEL_SUB_GROUP_INFO_COMPILE_NUM_SUB_GROUPS";
+                    break;
+                case UR_KERNEL_SUB_GROUP_INFO_SUB_GROUP_SIZE_INTEL:
+                    os << "UR_KERNEL_SUB_GROUP_INFO_SUB_GROUP_SIZE_INTEL";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_kernel_sub_group_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_kernel_sub_group_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_KERNEL_SUB_GROUP_INFO_MAX_SUB_GROUP_SIZE: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_KERNEL_SUB_GROUP_INFO_MAX_NUM_SUB_GROUPS: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_KERNEL_SUB_GROUP_INFO_COMPILE_NUM_SUB_GROUPS: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_KERNEL_SUB_GROUP_INFO_SUB_GROUP_SIZE_INTEL: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_kernel_cache_config_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_kernel_cache_config_t value) {
+        switch (value) {
+                case UR_KERNEL_CACHE_CONFIG_DEFAULT:
+                    os << "UR_KERNEL_CACHE_CONFIG_DEFAULT";
+                    break;
+                case UR_KERNEL_CACHE_CONFIG_LARGE_SLM:
+                    os << "UR_KERNEL_CACHE_CONFIG_LARGE_SLM";
+                    break;
+                case UR_KERNEL_CACHE_CONFIG_LARGE_DATA:
+                    os << "UR_KERNEL_CACHE_CONFIG_LARGE_DATA";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_kernel_exec_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_kernel_exec_info_t value) {
+        switch (value) {
+                case UR_KERNEL_EXEC_INFO_USM_INDIRECT_ACCESS:
+                    os << "UR_KERNEL_EXEC_INFO_USM_INDIRECT_ACCESS";
+                    break;
+                case UR_KERNEL_EXEC_INFO_USM_PTRS:
+                    os << "UR_KERNEL_EXEC_INFO_USM_PTRS";
+                    break;
+                case UR_KERNEL_EXEC_INFO_CACHE_CONFIG:
+                    os << "UR_KERNEL_EXEC_INFO_CACHE_CONFIG";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_kernel_exec_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_kernel_exec_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_KERNEL_EXEC_INFO_USM_INDIRECT_ACCESS: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_KERNEL_EXEC_INFO_USM_PTRS: {
+                    
+                    const void * const *tptr = (const void * const*)ptr;
+                            os << "{";
+                            size_t nelems = size / sizeof(void *);
+                            for (size_t i = 0; i < nelems; ++i) {
+                                if (i != 0) {
+                                    os << ", ";
+                                }
+                                
+        os << 
+                                    tptr[i]
+                                ;
+
+                            }
+                            os << "}";
+                } break;
+                case UR_KERNEL_EXEC_INFO_CACHE_CONFIG: {
+                    const ur_kernel_cache_config_t *tptr = (const ur_kernel_cache_config_t *)ptr;
+                    if (sizeof(ur_kernel_cache_config_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_kernel_cache_config_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_create_with_native_handle_params_t type
+/// @brief Print operator for the ur_kernel_arg_pointer_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_create_with_native_handle_params_t *params) {
-
-    os << ".hNativeKernel = ";
-
-    ur::details::printPtr(os, reinterpret_cast<void *>(
-                                  *(params->phNativeKernel)));
-
-    os << ", ";
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".hProgram = ";
-
-    ur::details::printPtr(os,
-                          *(params->phProgram));
-
-    os << ", ";
-    os << ".pProperties = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
-
-    os << ", ";
-    os << ".phKernel = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_kernel_arg_pointer_properties_t params) {
+    os << "(struct ur_kernel_arg_pointer_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphKernel));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_get_suggested_local_work_size_params_t type
+/// @brief Print operator for the ur_kernel_exec_info_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_get_suggested_local_work_size_params_t *params) {
-
-    os << ".hKernel = ";
-
-    ur::details::printPtr(os,
-                          *(params->phKernel));
-
-    os << ", ";
-    os << ".hQueue = ";
-
-    ur::details::printPtr(os,
-                          *(params->phQueue));
-
-    os << ", ";
-    os << ".numWorkDim = ";
-
-    os << *(params->pnumWorkDim);
-
-    os << ", ";
-    os << ".pGlobalWorkOffset = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppGlobalWorkOffset));
-
-    os << ", ";
-    os << ".pGlobalWorkSize = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppGlobalWorkSize));
-
-    os << ", ";
-    os << ".pSuggestedLocalWorkSize = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_kernel_exec_info_properties_t params) {
+    os << "(struct ur_kernel_exec_info_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppSuggestedLocalWorkSize));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_set_arg_value_params_t type
+/// @brief Print operator for the ur_kernel_arg_sampler_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_set_arg_value_params_t *params) {
-
-    os << ".hKernel = ";
-
-    ur::details::printPtr(os,
-                          *(params->phKernel));
-
-    os << ", ";
-    os << ".argIndex = ";
-
-    os << *(params->pargIndex);
-
-    os << ", ";
-    os << ".argSize = ";
-
-    os << *(params->pargSize);
-
-    os << ", ";
-    os << ".pProperties = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
-
-    os << ", ";
-    os << ".pArgValue = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_kernel_arg_sampler_properties_t params) {
+    os << "(struct ur_kernel_arg_sampler_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppArgValue));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_set_arg_local_params_t type
+/// @brief Print operator for the ur_kernel_arg_mem_obj_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_set_arg_local_params_t *params) {
-
-    os << ".hKernel = ";
-
-    ur::details::printPtr(os,
-                          *(params->phKernel));
-
-    os << ", ";
-    os << ".argIndex = ";
-
-    os << *(params->pargIndex);
-
-    os << ", ";
-    os << ".argSize = ";
-
-    os << *(params->pargSize);
-
-    os << ", ";
-    os << ".pProperties = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_kernel_arg_mem_obj_properties_t params) {
+    os << "(struct ur_kernel_arg_mem_obj_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".memoryAccess = ";
+        
+        ur::details::printFlag<ur_mem_flag_t>(os, 
+            (params.memoryAccess)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_set_arg_pointer_params_t type
+/// @brief Print operator for the ur_kernel_native_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_set_arg_pointer_params_t *params) {
-
-    os << ".hKernel = ";
-
-    ur::details::printPtr(os,
-                          *(params->phKernel));
-
-    os << ", ";
-    os << ".argIndex = ";
-
-    os << *(params->pargIndex);
-
-    os << ", ";
-    os << ".pProperties = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
-
-    os << ", ";
-    os << ".pArgValue = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_kernel_native_properties_t params) {
+    os << "(struct ur_kernel_native_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".isNativeHandleOwned = ";
+        
+        os << 
+            (params.isNativeHandleOwned)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->ppArgValue));
 
+    os << "}";
     return os;
 }
-
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_queue_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_queue_info_t value) {
+        switch (value) {
+                case UR_QUEUE_INFO_CONTEXT:
+                    os << "UR_QUEUE_INFO_CONTEXT";
+                    break;
+                case UR_QUEUE_INFO_DEVICE:
+                    os << "UR_QUEUE_INFO_DEVICE";
+                    break;
+                case UR_QUEUE_INFO_DEVICE_DEFAULT:
+                    os << "UR_QUEUE_INFO_DEVICE_DEFAULT";
+                    break;
+                case UR_QUEUE_INFO_FLAGS:
+                    os << "UR_QUEUE_INFO_FLAGS";
+                    break;
+                case UR_QUEUE_INFO_REFERENCE_COUNT:
+                    os << "UR_QUEUE_INFO_REFERENCE_COUNT";
+                    break;
+                case UR_QUEUE_INFO_SIZE:
+                    os << "UR_QUEUE_INFO_SIZE";
+                    break;
+                case UR_QUEUE_INFO_EMPTY:
+                    os << "UR_QUEUE_INFO_EMPTY";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_queue_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_queue_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_QUEUE_INFO_CONTEXT: {
+                    const ur_context_handle_t *tptr = (const ur_context_handle_t *)ptr;
+                    if (sizeof(ur_context_handle_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_context_handle_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printPtr(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_QUEUE_INFO_DEVICE: {
+                    const ur_device_handle_t *tptr = (const ur_device_handle_t *)ptr;
+                    if (sizeof(ur_device_handle_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_device_handle_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printPtr(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_QUEUE_INFO_DEVICE_DEFAULT: {
+                    const ur_queue_handle_t *tptr = (const ur_queue_handle_t *)ptr;
+                    if (sizeof(ur_queue_handle_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_queue_handle_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printPtr(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_QUEUE_INFO_FLAGS: {
+                    const ur_queue_flags_t *tptr = (const ur_queue_flags_t *)ptr;
+                    if (sizeof(ur_queue_flags_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_queue_flags_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printFlag<ur_queue_flag_t>(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_QUEUE_INFO_REFERENCE_COUNT: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_QUEUE_INFO_SIZE: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_QUEUE_INFO_EMPTY: {
+                    const ur_bool_t *tptr = (const ur_bool_t *)ptr;
+                    if (sizeof(ur_bool_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_bool_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_queue_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_queue_flag_t value) {
+        switch (value) {
+                case UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE:
+                    os << "UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE";
+                    break;
+                case UR_QUEUE_FLAG_PROFILING_ENABLE:
+                    os << "UR_QUEUE_FLAG_PROFILING_ENABLE";
+                    break;
+                case UR_QUEUE_FLAG_ON_DEVICE:
+                    os << "UR_QUEUE_FLAG_ON_DEVICE";
+                    break;
+                case UR_QUEUE_FLAG_ON_DEVICE_DEFAULT:
+                    os << "UR_QUEUE_FLAG_ON_DEVICE_DEFAULT";
+                    break;
+                case UR_QUEUE_FLAG_DISCARD_EVENTS:
+                    os << "UR_QUEUE_FLAG_DISCARD_EVENTS";
+                    break;
+                case UR_QUEUE_FLAG_PRIORITY_LOW:
+                    os << "UR_QUEUE_FLAG_PRIORITY_LOW";
+                    break;
+                case UR_QUEUE_FLAG_PRIORITY_HIGH:
+                    os << "UR_QUEUE_FLAG_PRIORITY_HIGH";
+                    break;
+                case UR_QUEUE_FLAG_SUBMISSION_BATCHED:
+                    os << "UR_QUEUE_FLAG_SUBMISSION_BATCHED";
+                    break;
+                case UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE:
+                    os << "UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE";
+                    break;
+                case UR_QUEUE_FLAG_USE_DEFAULT_STREAM:
+                    os << "UR_QUEUE_FLAG_USE_DEFAULT_STREAM";
+                    break;
+                case UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM:
+                    os << "UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_queue_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_queue_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE) == (uint32_t)UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE) {
+                val ^= (uint32_t)UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE;
+            }
+            
+            if ((val & UR_QUEUE_FLAG_PROFILING_ENABLE) == (uint32_t)UR_QUEUE_FLAG_PROFILING_ENABLE) {
+                val ^= (uint32_t)UR_QUEUE_FLAG_PROFILING_ENABLE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_QUEUE_FLAG_PROFILING_ENABLE;
+            }
+            
+            if ((val & UR_QUEUE_FLAG_ON_DEVICE) == (uint32_t)UR_QUEUE_FLAG_ON_DEVICE) {
+                val ^= (uint32_t)UR_QUEUE_FLAG_ON_DEVICE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_QUEUE_FLAG_ON_DEVICE;
+            }
+            
+            if ((val & UR_QUEUE_FLAG_ON_DEVICE_DEFAULT) == (uint32_t)UR_QUEUE_FLAG_ON_DEVICE_DEFAULT) {
+                val ^= (uint32_t)UR_QUEUE_FLAG_ON_DEVICE_DEFAULT;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_QUEUE_FLAG_ON_DEVICE_DEFAULT;
+            }
+            
+            if ((val & UR_QUEUE_FLAG_DISCARD_EVENTS) == (uint32_t)UR_QUEUE_FLAG_DISCARD_EVENTS) {
+                val ^= (uint32_t)UR_QUEUE_FLAG_DISCARD_EVENTS;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_QUEUE_FLAG_DISCARD_EVENTS;
+            }
+            
+            if ((val & UR_QUEUE_FLAG_PRIORITY_LOW) == (uint32_t)UR_QUEUE_FLAG_PRIORITY_LOW) {
+                val ^= (uint32_t)UR_QUEUE_FLAG_PRIORITY_LOW;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_QUEUE_FLAG_PRIORITY_LOW;
+            }
+            
+            if ((val & UR_QUEUE_FLAG_PRIORITY_HIGH) == (uint32_t)UR_QUEUE_FLAG_PRIORITY_HIGH) {
+                val ^= (uint32_t)UR_QUEUE_FLAG_PRIORITY_HIGH;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_QUEUE_FLAG_PRIORITY_HIGH;
+            }
+            
+            if ((val & UR_QUEUE_FLAG_SUBMISSION_BATCHED) == (uint32_t)UR_QUEUE_FLAG_SUBMISSION_BATCHED) {
+                val ^= (uint32_t)UR_QUEUE_FLAG_SUBMISSION_BATCHED;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_QUEUE_FLAG_SUBMISSION_BATCHED;
+            }
+            
+            if ((val & UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE) == (uint32_t)UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE) {
+                val ^= (uint32_t)UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE;
+            }
+            
+            if ((val & UR_QUEUE_FLAG_USE_DEFAULT_STREAM) == (uint32_t)UR_QUEUE_FLAG_USE_DEFAULT_STREAM) {
+                val ^= (uint32_t)UR_QUEUE_FLAG_USE_DEFAULT_STREAM;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_QUEUE_FLAG_USE_DEFAULT_STREAM;
+            }
+            
+            if ((val & UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM) == (uint32_t)UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM) {
+                val ^= (uint32_t)UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_set_exec_info_params_t type
+/// @brief Print operator for the ur_queue_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_set_exec_info_params_t *params) {
-
-    os << ".hKernel = ";
-
-    ur::details::printPtr(os,
-                          *(params->phKernel));
-
-    os << ", ";
-    os << ".propName = ";
-
-    os << *(params->ppropName);
-
-    os << ", ";
-    os << ".propSize = ";
-
-    os << *(params->ppropSize);
-
-    os << ", ";
-    os << ".pProperties = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
+inline std::ostream &operator<<(std::ostream &os, const struct ur_queue_properties_t params) {
+    os << "(struct ur_queue_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".flags = ";
+        
+        ur::details::printFlag<ur_queue_flag_t>(os, 
+            (params.flags)
+        );
 
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_set_arg_sampler_params_t type
+/// @brief Print operator for the ur_queue_index_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_set_arg_sampler_params_t *params) {
-
-    os << ".hKernel = ";
-
-    ur::details::printPtr(os,
-                          *(params->phKernel));
-
-    os << ", ";
-    os << ".argIndex = ";
-
-    os << *(params->pargIndex);
-
-    os << ", ";
-    os << ".pProperties = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
-
-    os << ", ";
-    os << ".hArgValue = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_queue_index_properties_t params) {
+    os << "(struct ur_queue_index_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".computeIndex = ";
+        
+        os << 
+            (params.computeIndex)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->phArgValue));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_set_arg_mem_obj_params_t type
+/// @brief Print operator for the ur_queue_native_desc_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_set_arg_mem_obj_params_t *params) {
-
-    os << ".hKernel = ";
-
-    ur::details::printPtr(os,
-                          *(params->phKernel));
-
-    os << ", ";
-    os << ".argIndex = ";
-
-    os << *(params->pargIndex);
-
-    os << ", ";
-    os << ".pProperties = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
-
-    os << ", ";
-    os << ".hArgValue = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_queue_native_desc_t params) {
+    os << "(struct ur_queue_native_desc_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pNativeData = ";
+        
+        ur::details::printPtr(os, 
+            (params.pNativeData)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phArgValue));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_set_specialization_constants_params_t type
+/// @brief Print operator for the ur_queue_native_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_set_specialization_constants_params_t *params) {
-
-    os << ".hKernel = ";
-
-    ur::details::printPtr(os,
-                          *(params->phKernel));
-
-    os << ", ";
-    os << ".count = ";
-
-    os << *(params->pcount);
-
-    os << ", ";
-    os << ".pSpecConstants = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_queue_native_properties_t params) {
+    os << "(struct ur_queue_native_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".isNativeHandleOwned = ";
+        
+        os << 
+            (params.isNativeHandleOwned)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->ppSpecConstants));
 
+    os << "}";
     return os;
 }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_command_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_command_t value) {
+        switch (value) {
+                case UR_COMMAND_KERNEL_LAUNCH:
+                    os << "UR_COMMAND_KERNEL_LAUNCH";
+                    break;
+                case UR_COMMAND_EVENTS_WAIT:
+                    os << "UR_COMMAND_EVENTS_WAIT";
+                    break;
+                case UR_COMMAND_EVENTS_WAIT_WITH_BARRIER:
+                    os << "UR_COMMAND_EVENTS_WAIT_WITH_BARRIER";
+                    break;
+                case UR_COMMAND_MEM_BUFFER_READ:
+                    os << "UR_COMMAND_MEM_BUFFER_READ";
+                    break;
+                case UR_COMMAND_MEM_BUFFER_WRITE:
+                    os << "UR_COMMAND_MEM_BUFFER_WRITE";
+                    break;
+                case UR_COMMAND_MEM_BUFFER_READ_RECT:
+                    os << "UR_COMMAND_MEM_BUFFER_READ_RECT";
+                    break;
+                case UR_COMMAND_MEM_BUFFER_WRITE_RECT:
+                    os << "UR_COMMAND_MEM_BUFFER_WRITE_RECT";
+                    break;
+                case UR_COMMAND_MEM_BUFFER_COPY:
+                    os << "UR_COMMAND_MEM_BUFFER_COPY";
+                    break;
+                case UR_COMMAND_MEM_BUFFER_COPY_RECT:
+                    os << "UR_COMMAND_MEM_BUFFER_COPY_RECT";
+                    break;
+                case UR_COMMAND_MEM_BUFFER_FILL:
+                    os << "UR_COMMAND_MEM_BUFFER_FILL";
+                    break;
+                case UR_COMMAND_MEM_IMAGE_READ:
+                    os << "UR_COMMAND_MEM_IMAGE_READ";
+                    break;
+                case UR_COMMAND_MEM_IMAGE_WRITE:
+                    os << "UR_COMMAND_MEM_IMAGE_WRITE";
+                    break;
+                case UR_COMMAND_MEM_IMAGE_COPY:
+                    os << "UR_COMMAND_MEM_IMAGE_COPY";
+                    break;
+                case UR_COMMAND_MEM_BUFFER_MAP:
+                    os << "UR_COMMAND_MEM_BUFFER_MAP";
+                    break;
+                case UR_COMMAND_MEM_UNMAP:
+                    os << "UR_COMMAND_MEM_UNMAP";
+                    break;
+                case UR_COMMAND_USM_FILL:
+                    os << "UR_COMMAND_USM_FILL";
+                    break;
+                case UR_COMMAND_USM_MEMCPY:
+                    os << "UR_COMMAND_USM_MEMCPY";
+                    break;
+                case UR_COMMAND_USM_PREFETCH:
+                    os << "UR_COMMAND_USM_PREFETCH";
+                    break;
+                case UR_COMMAND_USM_ADVISE:
+                    os << "UR_COMMAND_USM_ADVISE";
+                    break;
+                case UR_COMMAND_USM_FILL_2D:
+                    os << "UR_COMMAND_USM_FILL_2D";
+                    break;
+                case UR_COMMAND_USM_MEMCPY_2D:
+                    os << "UR_COMMAND_USM_MEMCPY_2D";
+                    break;
+                case UR_COMMAND_DEVICE_GLOBAL_VARIABLE_WRITE:
+                    os << "UR_COMMAND_DEVICE_GLOBAL_VARIABLE_WRITE";
+                    break;
+                case UR_COMMAND_DEVICE_GLOBAL_VARIABLE_READ:
+                    os << "UR_COMMAND_DEVICE_GLOBAL_VARIABLE_READ";
+                    break;
+                case UR_COMMAND_READ_HOST_PIPE:
+                    os << "UR_COMMAND_READ_HOST_PIPE";
+                    break;
+                case UR_COMMAND_WRITE_HOST_PIPE:
+                    os << "UR_COMMAND_WRITE_HOST_PIPE";
+                    break;
+                case UR_COMMAND_COMMAND_BUFFER_ENQUEUE_EXP:
+                    os << "UR_COMMAND_COMMAND_BUFFER_ENQUEUE_EXP";
+                    break;
+                case UR_COMMAND_EXTERNAL_SEMAPHORE_WAIT_EXP:
+                    os << "UR_COMMAND_EXTERNAL_SEMAPHORE_WAIT_EXP";
+                    break;
+                case UR_COMMAND_EXTERNAL_SEMAPHORE_SIGNAL_EXP:
+                    os << "UR_COMMAND_EXTERNAL_SEMAPHORE_SIGNAL_EXP";
+                    break;
+                case UR_COMMAND_TIMESTAMP_RECORDING_EXP:
+                    os << "UR_COMMAND_TIMESTAMP_RECORDING_EXP";
+                    break;
+                case UR_COMMAND_ENQUEUE_NATIVE_EXP:
+                    os << "UR_COMMAND_ENQUEUE_NATIVE_EXP";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_event_status_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_event_status_t value) {
+        switch (value) {
+                case UR_EVENT_STATUS_COMPLETE:
+                    os << "UR_EVENT_STATUS_COMPLETE";
+                    break;
+                case UR_EVENT_STATUS_RUNNING:
+                    os << "UR_EVENT_STATUS_RUNNING";
+                    break;
+                case UR_EVENT_STATUS_SUBMITTED:
+                    os << "UR_EVENT_STATUS_SUBMITTED";
+                    break;
+                case UR_EVENT_STATUS_QUEUED:
+                    os << "UR_EVENT_STATUS_QUEUED";
+                    break;
+                case UR_EVENT_STATUS_ERROR:
+                    os << "UR_EVENT_STATUS_ERROR";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_event_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_event_info_t value) {
+        switch (value) {
+                case UR_EVENT_INFO_COMMAND_QUEUE:
+                    os << "UR_EVENT_INFO_COMMAND_QUEUE";
+                    break;
+                case UR_EVENT_INFO_CONTEXT:
+                    os << "UR_EVENT_INFO_CONTEXT";
+                    break;
+                case UR_EVENT_INFO_COMMAND_TYPE:
+                    os << "UR_EVENT_INFO_COMMAND_TYPE";
+                    break;
+                case UR_EVENT_INFO_COMMAND_EXECUTION_STATUS:
+                    os << "UR_EVENT_INFO_COMMAND_EXECUTION_STATUS";
+                    break;
+                case UR_EVENT_INFO_REFERENCE_COUNT:
+                    os << "UR_EVENT_INFO_REFERENCE_COUNT";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_event_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_event_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_EVENT_INFO_COMMAND_QUEUE: {
+                    const ur_queue_handle_t *tptr = (const ur_queue_handle_t *)ptr;
+                    if (sizeof(ur_queue_handle_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_queue_handle_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printPtr(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_EVENT_INFO_CONTEXT: {
+                    const ur_context_handle_t *tptr = (const ur_context_handle_t *)ptr;
+                    if (sizeof(ur_context_handle_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_context_handle_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        ur::details::printPtr(os, 
+                        *tptr
+                    );
+
+                    os << ")";
+                } break;
+                case UR_EVENT_INFO_COMMAND_TYPE: {
+                    const ur_command_t *tptr = (const ur_command_t *)ptr;
+                    if (sizeof(ur_command_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_command_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_EVENT_INFO_COMMAND_EXECUTION_STATUS: {
+                    const ur_event_status_t *tptr = (const ur_event_status_t *)ptr;
+                    if (sizeof(ur_event_status_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(ur_event_status_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_EVENT_INFO_REFERENCE_COUNT: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_profiling_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_profiling_info_t value) {
+        switch (value) {
+                case UR_PROFILING_INFO_COMMAND_QUEUED:
+                    os << "UR_PROFILING_INFO_COMMAND_QUEUED";
+                    break;
+                case UR_PROFILING_INFO_COMMAND_SUBMIT:
+                    os << "UR_PROFILING_INFO_COMMAND_SUBMIT";
+                    break;
+                case UR_PROFILING_INFO_COMMAND_START:
+                    os << "UR_PROFILING_INFO_COMMAND_START";
+                    break;
+                case UR_PROFILING_INFO_COMMAND_END:
+                    os << "UR_PROFILING_INFO_COMMAND_END";
+                    break;
+                case UR_PROFILING_INFO_COMMAND_COMPLETE:
+                    os << "UR_PROFILING_INFO_COMMAND_COMPLETE";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_profiling_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_profiling_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_PROFILING_INFO_COMMAND_QUEUED: {
+                    const uint64_t *tptr = (const uint64_t *)ptr;
+                    if (sizeof(uint64_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_PROFILING_INFO_COMMAND_SUBMIT: {
+                    const uint64_t *tptr = (const uint64_t *)ptr;
+                    if (sizeof(uint64_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_PROFILING_INFO_COMMAND_START: {
+                    const uint64_t *tptr = (const uint64_t *)ptr;
+                    if (sizeof(uint64_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_PROFILING_INFO_COMMAND_END: {
+                    const uint64_t *tptr = (const uint64_t *)ptr;
+                    if (sizeof(uint64_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_PROFILING_INFO_COMMAND_COMPLETE: {
+                    const uint64_t *tptr = (const uint64_t *)ptr;
+                    if (sizeof(uint64_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint64_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_kernel_suggest_max_cooperative_group_count_exp_params_t type
+/// @brief Print operator for the ur_event_native_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_suggest_max_cooperative_group_count_exp_params_t *params) {
-
-    os << ".hKernel = ";
-
-    ur::details::printPtr(os,
-                          *(params->phKernel));
-
-    os << ", ";
-    os << ".localWorkSize = ";
-
-    os << *(params->plocalWorkSize);
-
-    os << ", ";
-    os << ".dynamicSharedMemorySize = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_event_native_properties_t params) {
+    os << "(struct ur_event_native_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".isNativeHandleOwned = ";
+        
+        os << 
+            (params.isNativeHandleOwned)
+        ;
 
-    os << *(params->pdynamicSharedMemorySize);
 
-    os << ", ";
-    os << ".pGroupCountRet = ";
+    os << "}";
+    return os;
+}
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_execution_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_execution_info_t value) {
+        switch (value) {
+                case UR_EXECUTION_INFO_COMPLETE:
+                    os << "UR_EXECUTION_INFO_COMPLETE";
+                    break;
+                case UR_EXECUTION_INFO_RUNNING:
+                    os << "UR_EXECUTION_INFO_RUNNING";
+                    break;
+                case UR_EXECUTION_INFO_SUBMITTED:
+                    os << "UR_EXECUTION_INFO_SUBMITTED";
+                    break;
+                case UR_EXECUTION_INFO_QUEUED:
+                    os << "UR_EXECUTION_INFO_QUEUED";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_map_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_map_flag_t value) {
+        switch (value) {
+                case UR_MAP_FLAG_READ:
+                    os << "UR_MAP_FLAG_READ";
+                    break;
+                case UR_MAP_FLAG_WRITE:
+                    os << "UR_MAP_FLAG_WRITE";
+                    break;
+                case UR_MAP_FLAG_WRITE_INVALIDATE_REGION:
+                    os << "UR_MAP_FLAG_WRITE_INVALIDATE_REGION";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_map_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_map_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_MAP_FLAG_READ) == (uint32_t)UR_MAP_FLAG_READ) {
+                val ^= (uint32_t)UR_MAP_FLAG_READ;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_MAP_FLAG_READ;
+            }
+            
+            if ((val & UR_MAP_FLAG_WRITE) == (uint32_t)UR_MAP_FLAG_WRITE) {
+                val ^= (uint32_t)UR_MAP_FLAG_WRITE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_MAP_FLAG_WRITE;
+            }
+            
+            if ((val & UR_MAP_FLAG_WRITE_INVALIDATE_REGION) == (uint32_t)UR_MAP_FLAG_WRITE_INVALIDATE_REGION) {
+                val ^= (uint32_t)UR_MAP_FLAG_WRITE_INVALIDATE_REGION;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_MAP_FLAG_WRITE_INVALIDATE_REGION;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_usm_migration_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_usm_migration_flag_t value) {
+        switch (value) {
+                case UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE:
+                    os << "UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE";
+                    break;
+                case UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST:
+                    os << "UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_usm_migration_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_usm_migration_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE) == (uint32_t)UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE) {
+                val ^= (uint32_t)UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE;
+            }
+            
+            if ((val & UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) == (uint32_t)UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) {
+                val ^= (uint32_t)UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_exp_image_copy_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_exp_image_copy_flag_t value) {
+        switch (value) {
+                case UR_EXP_IMAGE_COPY_FLAG_HOST_TO_DEVICE:
+                    os << "UR_EXP_IMAGE_COPY_FLAG_HOST_TO_DEVICE";
+                    break;
+                case UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_HOST:
+                    os << "UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_HOST";
+                    break;
+                case UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_DEVICE:
+                    os << "UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_DEVICE";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_exp_image_copy_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_exp_image_copy_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_EXP_IMAGE_COPY_FLAG_HOST_TO_DEVICE) == (uint32_t)UR_EXP_IMAGE_COPY_FLAG_HOST_TO_DEVICE) {
+                val ^= (uint32_t)UR_EXP_IMAGE_COPY_FLAG_HOST_TO_DEVICE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_EXP_IMAGE_COPY_FLAG_HOST_TO_DEVICE;
+            }
+            
+            if ((val & UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_HOST) == (uint32_t)UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_HOST) {
+                val ^= (uint32_t)UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_HOST;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_HOST;
+            }
+            
+            if ((val & UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_DEVICE) == (uint32_t)UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_DEVICE) {
+                val ^= (uint32_t)UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_DEVICE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_EXP_IMAGE_COPY_FLAG_DEVICE_TO_DEVICE;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_exp_sampler_cubemap_filter_mode_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_exp_sampler_cubemap_filter_mode_t value) {
+        switch (value) {
+                case UR_EXP_SAMPLER_CUBEMAP_FILTER_MODE_DISJOINTED:
+                    os << "UR_EXP_SAMPLER_CUBEMAP_FILTER_MODE_DISJOINTED";
+                    break;
+                case UR_EXP_SAMPLER_CUBEMAP_FILTER_MODE_SEAMLESS:
+                    os << "UR_EXP_SAMPLER_CUBEMAP_FILTER_MODE_SEAMLESS";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_exp_external_mem_type_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_exp_external_mem_type_t value) {
+        switch (value) {
+                case UR_EXP_EXTERNAL_MEM_TYPE_OPAQUE_FD:
+                    os << "UR_EXP_EXTERNAL_MEM_TYPE_OPAQUE_FD";
+                    break;
+                case UR_EXP_EXTERNAL_MEM_TYPE_WIN32_NT:
+                    os << "UR_EXP_EXTERNAL_MEM_TYPE_WIN32_NT";
+                    break;
+                case UR_EXP_EXTERNAL_MEM_TYPE_WIN32_NT_DX12_RESOURCE:
+                    os << "UR_EXP_EXTERNAL_MEM_TYPE_WIN32_NT_DX12_RESOURCE";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_exp_external_semaphore_type_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_exp_external_semaphore_type_t value) {
+        switch (value) {
+                case UR_EXP_EXTERNAL_SEMAPHORE_TYPE_OPAQUE_FD:
+                    os << "UR_EXP_EXTERNAL_SEMAPHORE_TYPE_OPAQUE_FD";
+                    break;
+                case UR_EXP_EXTERNAL_SEMAPHORE_TYPE_WIN32_NT:
+                    os << "UR_EXP_EXTERNAL_SEMAPHORE_TYPE_WIN32_NT";
+                    break;
+                case UR_EXP_EXTERNAL_SEMAPHORE_TYPE_WIN32_NT_DX12_FENCE:
+                    os << "UR_EXP_EXTERNAL_SEMAPHORE_TYPE_WIN32_NT_DX12_FENCE";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_exp_file_descriptor_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_file_descriptor_t params) {
+    os << "(struct ur_exp_file_descriptor_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".fd = ";
+        
+        os << 
+            (params.fd)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->ppGroupCountRet));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_queue_get_info_params_t type
+/// @brief Print operator for the ur_exp_win32_handle_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_get_info_params_t *params) {
-
-    os << ".hQueue = ";
-
-    ur::details::printPtr(os,
-                          *(params->phQueue));
-
-    os << ", ";
-    os << ".propName = ";
-
-    os << *(params->ppropName);
-
-    os << ", ";
-    os << ".propSize = ";
-
-    os << *(params->ppropSize);
-
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
-
-    os << ", ";
-    os << ".pPropSizeRet = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_win32_handle_t params) {
+    os << "(struct ur_exp_win32_handle_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".handle = ";
+        
+        ur::details::printPtr(os, 
+            (params.handle)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_queue_create_params_t type
+/// @brief Print operator for the ur_exp_sampler_mip_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_create_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".hDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->phDevice));
-
-    os << ", ";
-    os << ".pProperties = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
-
-    os << ", ";
-    os << ".phQueue = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_sampler_mip_properties_t params) {
+    os << "(struct ur_exp_sampler_mip_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".minMipmapLevelClamp = ";
+        
+        os << 
+            (params.minMipmapLevelClamp)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".maxMipmapLevelClamp = ";
+        
+        os << 
+            (params.maxMipmapLevelClamp)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".maxAnisotropy = ";
+        
+        os << 
+            (params.maxAnisotropy)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".mipFilterMode = ";
+        
+        os << 
+            (params.mipFilterMode)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->pphQueue));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_queue_retain_params_t type
+/// @brief Print operator for the ur_exp_sampler_addr_modes_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_retain_params_t *params) {
-
-    os << ".hQueue = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_sampler_addr_modes_t params) {
+    os << "(struct ur_exp_sampler_addr_modes_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".addrModes = {";
+        for(auto i = 0; i < 3; i++){
+            if(i != 0){
+                os << ", ";
+            }
+            
+        os << 
+                (params.addrModes[i])
+            ;
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
+        }
+        os << "}";
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_queue_release_params_t type
+/// @brief Print operator for the ur_exp_sampler_cubemap_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_release_params_t *params) {
-
-    os << ".hQueue = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_sampler_cubemap_properties_t params) {
+    os << "(struct ur_exp_sampler_cubemap_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".cubemapFilterMode = ";
+        
+        os << 
+            (params.cubemapFilterMode)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_queue_get_native_handle_params_t type
+/// @brief Print operator for the ur_exp_external_mem_desc_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_get_native_handle_params_t *params) {
-
-    os << ".hQueue = ";
-
-    ur::details::printPtr(os,
-                          *(params->phQueue));
-
-    os << ", ";
-    os << ".pDesc = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppDesc));
-
-    os << ", ";
-    os << ".phNativeQueue = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_external_mem_desc_t params) {
+    os << "(struct ur_exp_external_mem_desc_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphNativeQueue));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_queue_create_with_native_handle_params_t type
+/// @brief Print operator for the ur_exp_external_semaphore_desc_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_create_with_native_handle_params_t *params) {
-
-    os << ".hNativeQueue = ";
-
-    ur::details::printPtr(os, reinterpret_cast<void *>(
-                                  *(params->phNativeQueue)));
-
-    os << ", ";
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".hDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->phDevice));
-
-    os << ", ";
-    os << ".pProperties = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
-
-    os << ", ";
-    os << ".phQueue = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_external_semaphore_desc_t params) {
+    os << "(struct ur_exp_external_semaphore_desc_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphQueue));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_queue_finish_params_t type
+/// @brief Print operator for the ur_exp_image_copy_region_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_finish_params_t *params) {
-
-    os << ".hQueue = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_image_copy_region_t params) {
+    os << "(struct ur_exp_image_copy_region_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".srcOffset = ";
+        
+        os << 
+            (params.srcOffset)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".dstOffset = ";
+        
+        os << 
+            (params.dstOffset)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".copyExtent = ";
+        
+        os << 
+            (params.copyExtent)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
 
+    os << "}";
     return os;
 }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_device_command_buffer_update_capability_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_device_command_buffer_update_capability_flag_t value) {
+        switch (value) {
+                case UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_ARGUMENTS:
+                    os << "UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_ARGUMENTS";
+                    break;
+                case UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_LOCAL_WORK_SIZE:
+                    os << "UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_LOCAL_WORK_SIZE";
+                    break;
+                case UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_SIZE:
+                    os << "UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_SIZE";
+                    break;
+                case UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_OFFSET:
+                    os << "UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_OFFSET";
+                    break;
+                case UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_HANDLE:
+                    os << "UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_HANDLE";
+                    break;
+                case UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_EVENTS:
+                    os << "UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_EVENTS";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_device_command_buffer_update_capability_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_device_command_buffer_update_capability_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_ARGUMENTS) == (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_ARGUMENTS) {
+                val ^= (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_ARGUMENTS;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_ARGUMENTS;
+            }
+            
+            if ((val & UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_LOCAL_WORK_SIZE) == (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_LOCAL_WORK_SIZE) {
+                val ^= (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_LOCAL_WORK_SIZE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_LOCAL_WORK_SIZE;
+            }
+            
+            if ((val & UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_SIZE) == (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_SIZE) {
+                val ^= (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_SIZE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_SIZE;
+            }
+            
+            if ((val & UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_OFFSET) == (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_OFFSET) {
+                val ^= (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_OFFSET;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_GLOBAL_WORK_OFFSET;
+            }
+            
+            if ((val & UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_HANDLE) == (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_HANDLE) {
+                val ^= (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_HANDLE;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_KERNEL_HANDLE;
+            }
+            
+            if ((val & UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_EVENTS) == (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_EVENTS) {
+                val ^= (uint32_t)UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_EVENTS;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_DEVICE_COMMAND_BUFFER_UPDATE_CAPABILITY_FLAG_EVENTS;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_exp_command_buffer_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_exp_command_buffer_info_t value) {
+        switch (value) {
+                case UR_EXP_COMMAND_BUFFER_INFO_REFERENCE_COUNT:
+                    os << "UR_EXP_COMMAND_BUFFER_INFO_REFERENCE_COUNT";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_exp_command_buffer_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_exp_command_buffer_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_EXP_COMMAND_BUFFER_INFO_REFERENCE_COUNT: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_exp_command_buffer_command_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_exp_command_buffer_command_info_t value) {
+        switch (value) {
+                case UR_EXP_COMMAND_BUFFER_COMMAND_INFO_REFERENCE_COUNT:
+                    os << "UR_EXP_COMMAND_BUFFER_COMMAND_INFO_REFERENCE_COUNT";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_exp_command_buffer_command_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_exp_command_buffer_command_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_EXP_COMMAND_BUFFER_COMMAND_INFO_REFERENCE_COUNT: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_queue_flush_params_t type
+/// @brief Print operator for the ur_exp_command_buffer_desc_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_flush_params_t *params) {
-
-    os << ".hQueue = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_command_buffer_desc_t params) {
+    os << "(struct ur_exp_command_buffer_desc_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".isUpdatable = ";
+        
+        os << 
+            (params.isUpdatable)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".isInOrder = ";
+        
+        os << 
+            (params.isInOrder)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".enableProfiling = ";
+        
+        os << 
+            (params.enableProfiling)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_sampler_create_params_t type
+/// @brief Print operator for the ur_exp_command_buffer_update_memobj_arg_desc_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_sampler_create_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".pDesc = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppDesc));
-
-    os << ", ";
-    os << ".phSampler = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_command_buffer_update_memobj_arg_desc_t params) {
+    os << "(struct ur_exp_command_buffer_update_memobj_arg_desc_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".argIndex = ";
+        
+        os << 
+            (params.argIndex)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        os << 
+            (params.pProperties)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".hNewMemObjArg = ";
+        
+        ur::details::printPtr(os, 
+            (params.hNewMemObjArg)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphSampler));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_sampler_retain_params_t type
+/// @brief Print operator for the ur_exp_command_buffer_update_pointer_arg_desc_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_sampler_retain_params_t *params) {
-
-    os << ".hSampler = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_command_buffer_update_pointer_arg_desc_t params) {
+    os << "(struct ur_exp_command_buffer_update_pointer_arg_desc_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".argIndex = ";
+        
+        os << 
+            (params.argIndex)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        os << 
+            (params.pProperties)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNewPointerArg = ";
+        
+        os << 
+            (params.pNewPointerArg)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->phSampler));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_sampler_release_params_t type
+/// @brief Print operator for the ur_exp_command_buffer_update_value_arg_desc_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_sampler_release_params_t *params) {
-
-    os << ".hSampler = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_command_buffer_update_value_arg_desc_t params) {
+    os << "(struct ur_exp_command_buffer_update_value_arg_desc_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".argIndex = ";
+        
+        os << 
+            (params.argIndex)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".argSize = ";
+        
+        os << 
+            (params.argSize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        os << 
+            (params.pProperties)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNewValueArg = ";
+        
+        os << 
+            (params.pNewValueArg)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->phSampler));
 
+    os << "}";
     return os;
 }
-
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_sampler_get_info_params_t type
+/// @brief Print operator for the ur_exp_command_buffer_update_kernel_launch_desc_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_sampler_get_info_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_command_buffer_update_kernel_launch_desc_t params) {
+    os << "(struct ur_exp_command_buffer_update_kernel_launch_desc_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hNewKernel = ";
+        
+        ur::details::printPtr(os, 
+            (params.hNewKernel)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numNewMemObjArgs = ";
+        
+        os << 
+            (params.numNewMemObjArgs)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numNewPointerArgs = ";
+        
+        os << 
+            (params.numNewPointerArgs)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numNewValueArgs = ";
+        
+        os << 
+            (params.numNewValueArgs)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".newWorkDim = ";
+        
+        os << 
+            (params.newWorkDim)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNewMemObjArgList = {";
+        for (size_t i = 0; (params.pNewMemObjArgList) != NULL && i < params.numNewMemObjArgs; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        os << 
+                ((params.pNewMemObjArgList))[i]
+            ;
+
+        }
+        os << "}";
+
+        
+    
+        os << ", ";
+        os << ".pNewPointerArgList = {";
+        for (size_t i = 0; (params.pNewPointerArgList) != NULL && i < params.numNewPointerArgs; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        os << 
+                ((params.pNewPointerArgList))[i]
+            ;
 
-    os << ".hSampler = ";
+        }
+        os << "}";
 
-    ur::details::printPtr(os,
-                          *(params->phSampler));
+        
+    
+        os << ", ";
+        os << ".pNewValueArgList = {";
+        for (size_t i = 0; (params.pNewValueArgList) != NULL && i < params.numNewValueArgs; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        os << 
+                ((params.pNewValueArgList))[i]
+            ;
 
-    os << ", ";
-    os << ".propName = ";
+        }
+        os << "}";
 
-    os << *(params->ppropName);
+        
+    
+        os << ", ";
+        os << ".pNewGlobalWorkOffset = {";
+        for (size_t i = 0; (params.pNewGlobalWorkOffset) != NULL && i < params.newWorkDim; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        os << 
+                ((params.pNewGlobalWorkOffset))[i]
+            ;
 
-    os << ", ";
-    os << ".propSize = ";
+        }
+        os << "}";
 
-    os << *(params->ppropSize);
+        
+    
+        os << ", ";
+        os << ".pNewGlobalWorkSize = {";
+        for (size_t i = 0; (params.pNewGlobalWorkSize) != NULL && i < params.newWorkDim; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        os << 
+                ((params.pNewGlobalWorkSize))[i]
+            ;
 
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".pPropSizeRet = ";
+        
+    
+        os << ", ";
+        os << ".pNewLocalWorkSize = {";
+        for (size_t i = 0; (params.pNewLocalWorkSize) != NULL && i < params.newWorkDim; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        os << 
+                ((params.pNewLocalWorkSize))[i]
+            ;
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
+        }
+        os << "}";
 
+    os << "}";
     return os;
 }
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_exp_launch_property_id_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_exp_launch_property_id_t value) {
+        switch (value) {
+                case UR_EXP_LAUNCH_PROPERTY_ID_IGNORE:
+                    os << "UR_EXP_LAUNCH_PROPERTY_ID_IGNORE";
+                    break;
+                case UR_EXP_LAUNCH_PROPERTY_ID_COOPERATIVE:
+                    os << "UR_EXP_LAUNCH_PROPERTY_ID_COOPERATIVE";
+                    break;
+                case UR_EXP_LAUNCH_PROPERTY_ID_CLUSTER_DIMENSION:
+                    os << "UR_EXP_LAUNCH_PROPERTY_ID_CLUSTER_DIMENSION";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+namespace ur::details {
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_sampler_get_native_handle_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_sampler_get_native_handle_params_t *params) {
+    ///////////////////////////////////////////////////////////////////////////////
+    // @brief Print ur_exp_launch_property_value_t union
+    inline ur_result_t printUnion(
+    std::ostream &os,
+    const union ur_exp_launch_property_value_t params,
+    const enum ur_exp_launch_property_id_t tag
+){
+    os << "(union ur_exp_launch_property_value_t){";
 
-    os << ".hSampler = ";
+    switch(tag){
+    case UR_EXP_LAUNCH_PROPERTY_ID_CLUSTER_DIMENSION:
+        
+    
+        os << ".clusterDim = {";
+        for(auto i = 0; i < 3; i++){
+            if(i != 0){
+                os << ", ";
+            }
+            
+        os << 
+                (params.clusterDim[i])
+            ;
 
-    ur::details::printPtr(os,
-                          *(params->phSampler));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".phNativeSampler = ";
+        break;
+    case UR_EXP_LAUNCH_PROPERTY_ID_COOPERATIVE:
+        
+    
+        os << ".cooperative = ";
+        
+        os << 
+            (params.cooperative)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->pphNativeSampler));
 
-    return os;
+        break;
+    default:
+        os << "<unknown>";
+        return UR_RESULT_ERROR_INVALID_ENUMERATION;
+    }
+    os << "}";
+    return UR_RESULT_SUCCESS;
 }
-
+} // namespace ur::details
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_sampler_create_with_native_handle_params_t type
+/// @brief Print operator for the ur_exp_launch_property_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_sampler_create_with_native_handle_params_t *params) {
-
-    os << ".hNativeSampler = ";
-
-    ur::details::printPtr(os, reinterpret_cast<void *>(
-                                  *(params->phNativeSampler)));
-
-    os << ", ";
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".pProperties = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
-
-    os << ", ";
-    os << ".phSampler = ";
-
-    ur::details::printPtr(os,
-                          *(params->pphSampler));
+inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_launch_property_t params) {
+    os << "(struct ur_exp_launch_property_t){";
+    
+        
+    
+        os << ".id = ";
+        
+        os << 
+            (params.id)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".value = ";
+        ur::details::printUnion(os, (params.value), params.id);
 
+    os << "}";
     return os;
 }
-
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_exp_peer_info_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_exp_peer_info_t value) {
+        switch (value) {
+                case UR_EXP_PEER_INFO_UR_PEER_ACCESS_SUPPORTED:
+                    os << "UR_EXP_PEER_INFO_UR_PEER_ACCESS_SUPPORTED";
+                    break;
+                case UR_EXP_PEER_INFO_UR_PEER_ATOMICS_SUPPORTED:
+                    os << "UR_EXP_PEER_INFO_UR_PEER_ATOMICS_SUPPORTED";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_exp_peer_info_t enum value
+    template <>
+    inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_exp_peer_info_t value, size_t size) {
+        if (ptr == NULL) {
+            return printPtr(os, ptr);
+        }
+
+        switch (value) {
+                case UR_EXP_PEER_INFO_UR_PEER_ACCESS_SUPPORTED: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                case UR_EXP_PEER_INFO_UR_PEER_ATOMICS_SUPPORTED: {
+                    const uint32_t *tptr = (const uint32_t *)ptr;
+                    if (sizeof(uint32_t) > size) {
+                        os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+                        return UR_RESULT_ERROR_INVALID_SIZE;
+                    }
+                    os << (const void *)(tptr) << " (";
+                    
+        os << 
+                        *tptr
+                    ;
+
+                    os << ")";
+                } break;
+                default:
+                    os << "unknown enumerator";
+                    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print operator for the ur_exp_enqueue_native_command_flag_t type
+    /// @returns
+    ///     std::ostream &
+    inline std::ostream &operator<<(std::ostream &os, enum ur_exp_enqueue_native_command_flag_t value) {
+        switch (value) {
+                case UR_EXP_ENQUEUE_NATIVE_COMMAND_FLAG_TBD:
+                    os << "UR_EXP_ENQUEUE_NATIVE_COMMAND_FLAG_TBD";
+                    break;
+                default:
+                    os << "unknown enumerator";
+                    break;
+        }
+        return os;
+    }
+
+    namespace ur::details {
+    ///////////////////////////////////////////////////////////////////////////////
+    /// @brief Print ur_exp_enqueue_native_command_flag_t flag
+    template<>
+    inline ur_result_t printFlag<ur_exp_enqueue_native_command_flag_t>(std::ostream &os, uint32_t flag) {
+        uint32_t val = flag;
+        bool first = true;
+            
+            if ((val & UR_EXP_ENQUEUE_NATIVE_COMMAND_FLAG_TBD) == (uint32_t)UR_EXP_ENQUEUE_NATIVE_COMMAND_FLAG_TBD) {
+                val ^= (uint32_t)UR_EXP_ENQUEUE_NATIVE_COMMAND_FLAG_TBD;
+                if (!first) {
+                    os << " | ";
+                } else {
+                    first = false;
+                }
+                os << UR_EXP_ENQUEUE_NATIVE_COMMAND_FLAG_TBD;
+            }
+        if (val != 0) {
+            std::bitset<32> bits(val);
+            if (!first) {
+                os << " | ";
+            }
+            os << "unknown bit flags " << bits;
+        } else if (first) {
+            os << "0";
+        }
+        return UR_RESULT_SUCCESS;
+    }
+    } // namespace ur::details
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_mem_image_create_params_t type
+/// @brief Print operator for the ur_exp_enqueue_native_command_properties_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_image_create_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".flags = ";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_enqueue_native_command_properties_t params) {
+    os << "(struct ur_exp_enqueue_native_command_properties_t){";
+    
+        
+    
+        os << ".stype = ";
+        
+        os << 
+            (params.stype)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pNext = ";
+        
+        ur::details::printStruct(os, 
+            (params.pNext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".flags = ";
+        
+        ur::details::printFlag<ur_exp_enqueue_native_command_flag_t>(os, 
+            (params.flags)
+        );
 
-    ur::details::printFlag<ur_mem_flag_t>(os,
-                                          *(params->pflags));
 
-    os << ", ";
-    os << ".pImageFormat = ";
+    os << "}";
+    return os;
+}
 
-    ur::details::printPtr(os,
-                          *(params->ppImageFormat));
 
-    os << ", ";
-    os << ".pImageDesc = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_loader_config_create_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_loader_config_create_params_t *params) {
+    
+        
+    
+        os << ".phLoaderConfig = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphLoaderConfig)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppImageDesc));
 
-    os << ", ";
-    os << ".pHost = ";
+    return os;
+}
 
-    ur::details::printPtr(os,
-                          *(params->ppHost));
 
-    os << ", ";
-    os << ".phMem = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_loader_config_retain_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_loader_config_retain_params_t *params) {
+    
+        
+    
+        os << ".hLoaderConfig = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phLoaderConfig)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphMem));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_mem_buffer_create_params_t type
+/// @brief Print operator for the ur_loader_config_release_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_buffer_create_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_loader_config_release_params_t *params) {
+    
+        
+    
+        os << ".hLoaderConfig = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phLoaderConfig)
+        );
+
+
+    return os;
+}
 
-    os << ".hContext = ";
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_loader_config_get_info_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_loader_config_get_info_params_t *params) {
+    
+        
+    
+        os << ".hLoaderConfig = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phLoaderConfig)
+        );
 
-    os << ", ";
-    os << ".flags = ";
 
-    ur::details::printFlag<ur_mem_flag_t>(os,
-                                          *(params->pflags));
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << ", ";
-    os << ".size = ";
 
-    os << *(params->psize);
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    os << ", ";
-    os << ".pProperties = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".phBuffer = ";
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphBuffer));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_mem_retain_params_t type
+/// @brief Print operator for the ur_loader_config_enable_layer_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_retain_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_loader_config_enable_layer_params_t *params) {
+    
+        
+    
+        os << ".hLoaderConfig = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phLoaderConfig)
+        );
 
-    os << ".hMem = ";
 
-    ur::details::printPtr(os,
-                          *(params->phMem));
+        
+    
+        os << ", ";
+        os << ".pLayerName = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppLayerName)
+        );
+
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_mem_release_params_t type
+/// @brief Print operator for the ur_loader_config_set_code_location_callback_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_release_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_loader_config_set_code_location_callback_params_t *params) {
+    
+        
+    
+        os << ".hLoaderConfig = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phLoaderConfig)
+        );
 
-    os << ".hMem = ";
 
-    ur::details::printPtr(os,
-                          *(params->phMem));
+        
+    
+        os << ", ";
+        os << ".pfnCodeloc = ";
+        
+        os << reinterpret_cast<void*>(
+            *(params->ppfnCodeloc)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pUserData = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppUserData)
+        );
+
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_mem_buffer_partition_params_t type
+/// @brief Print operator for the ur_loader_config_set_mocking_enabled_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_buffer_partition_params_t *params) {
-
-    os << ".hBuffer = ";
-
-    ur::details::printPtr(os,
-                          *(params->phBuffer));
-
-    os << ", ";
-    os << ".flags = ";
-
-    ur::details::printFlag<ur_mem_flag_t>(os,
-                                          *(params->pflags));
-
-    os << ", ";
-    os << ".bufferCreateType = ";
-
-    os << *(params->pbufferCreateType);
-
-    os << ", ";
-    os << ".pRegion = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_loader_config_set_mocking_enabled_params_t *params) {
+    
+        
+    
+        os << ".hLoaderConfig = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phLoaderConfig)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppRegion));
 
-    os << ", ";
-    os << ".phMem = ";
+        
+    
+        os << ", ";
+        os << ".enable = ";
+        
+        os << 
+            *(params->penable)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->pphMem));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_mem_get_native_handle_params_t type
+/// @brief Print operator for the ur_platform_get_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_get_native_handle_params_t *params) {
-
-    os << ".hMem = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_platform_get_params_t *params) {
+    
+        
+    
+        os << ".phAdapters = {";
+        for (size_t i = 0; *(params->pphAdapters) != NULL && i < *params->pNumAdapters; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphAdapters))[i]
+            );
 
-    ur::details::printPtr(os,
-                          *(params->phMem));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".hDevice = ";
+        
+    
+        os << ", ";
+        os << ".NumAdapters = ";
+        
+        os << 
+            *(params->pNumAdapters)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".NumEntries = ";
+        
+        os << 
+            *(params->pNumEntries)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phPlatforms = {";
+        for (size_t i = 0; *(params->pphPlatforms) != NULL && i < *params->pNumEntries; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphPlatforms))[i]
+            );
 
-    ur::details::printPtr(os,
-                          *(params->phDevice));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".phNativeMem = ";
+        
+    
+        os << ", ";
+        os << ".pNumPlatforms = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppNumPlatforms)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphNativeMem));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_mem_buffer_create_with_native_handle_params_t type
+/// @brief Print operator for the ur_platform_get_info_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_buffer_create_with_native_handle_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_platform_get_info_params_t *params) {
+    
+        
+    
+        os << ".hPlatform = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phPlatform)
+        );
 
-    os << ".hNativeMem = ";
 
-    ur::details::printPtr(os, reinterpret_cast<void *>(
-                                  *(params->phNativeMem)));
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << ", ";
-    os << ".hContext = ";
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    os << ", ";
-    os << ".pProperties = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".phMem = ";
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphMem));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_mem_image_create_with_native_handle_params_t type
+/// @brief Print operator for the ur_platform_get_native_handle_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_image_create_with_native_handle_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_platform_get_native_handle_params_t *params) {
+    
+        
+    
+        os << ".hPlatform = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phPlatform)
+        );
+
 
-    os << ".hNativeMem = ";
+        
+    
+        os << ", ";
+        os << ".phNativePlatform = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphNativePlatform)
+        );
 
-    ur::details::printPtr(os, reinterpret_cast<void *>(
-                                  *(params->phNativeMem)));
 
-    os << ", ";
-    os << ".hContext = ";
+    return os;
+}
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
 
-    os << ", ";
-    os << ".pImageFormat = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_platform_create_with_native_handle_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_platform_create_with_native_handle_params_t *params) {
+    
+        
+    
+        os << ".hNativePlatform = ";
+        
+        ur::details::printPtr(os, reinterpret_cast<void*>(
+            *(params->phNativePlatform)
+        ));
 
-    ur::details::printPtr(os,
-                          *(params->ppImageFormat));
 
-    os << ", ";
-    os << ".pImageDesc = ";
+        
+    
+        os << ", ";
+        os << ".hAdapter = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phAdapter)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppImageDesc));
 
-    os << ", ";
-    os << ".pProperties = ";
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
 
-    os << ", ";
-    os << ".phMem = ";
+        
+    
+        os << ", ";
+        os << ".phPlatform = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphPlatform)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphMem));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_mem_get_info_params_t type
+/// @brief Print operator for the ur_platform_get_api_version_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_get_info_params_t *params) {
-
-    os << ".hMemory = ";
-
-    ur::details::printPtr(os,
-                          *(params->phMemory));
-
-    os << ", ";
-    os << ".propName = ";
-
-    os << *(params->ppropName);
-
-    os << ", ";
-    os << ".propSize = ";
-
-    os << *(params->ppropSize);
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_platform_get_api_version_params_t *params) {
+    
+        
+    
+        os << ".hPlatform = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phPlatform)
+        );
 
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".pPropSizeRet = ";
+        
+    
+        os << ", ";
+        os << ".pVersion = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppVersion)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_mem_image_get_info_params_t type
+/// @brief Print operator for the ur_platform_get_backend_option_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_image_get_info_params_t *params) {
-
-    os << ".hMemory = ";
-
-    ur::details::printPtr(os,
-                          *(params->phMemory));
-
-    os << ", ";
-    os << ".propName = ";
-
-    os << *(params->ppropName);
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_platform_get_backend_option_params_t *params) {
+    
+        
+    
+        os << ".hPlatform = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phPlatform)
+        );
 
-    os << ", ";
-    os << ".propSize = ";
 
-    os << *(params->ppropSize);
+        
+    
+        os << ", ";
+        os << ".pFrontendOption = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppFrontendOption)
+        );
 
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".pPropSizeRet = ";
+        
+    
+        os << ", ";
+        os << ".ppPlatformOption = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pppPlatformOption)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_physical_mem_create_params_t type
+/// @brief Print operator for the ur_context_create_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_physical_mem_create_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".hDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->phDevice));
-
-    os << ", ";
-    os << ".size = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_context_create_params_t *params) {
+    
+        
+    
+        os << ".DeviceCount = ";
+        
+        os << 
+            *(params->pDeviceCount)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phDevices = {";
+        for (size_t i = 0; *(params->pphDevices) != NULL && i < *params->pDeviceCount; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphDevices))[i]
+            );
 
-    os << *(params->psize);
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".pProperties = ";
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
 
-    os << ", ";
-    os << ".phPhysicalMem = ";
+        
+    
+        os << ", ";
+        os << ".phContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphContext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphPhysicalMem));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_physical_mem_retain_params_t type
+/// @brief Print operator for the ur_context_retain_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_physical_mem_retain_params_t *params) {
-
-    os << ".hPhysicalMem = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_context_retain_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phPhysicalMem));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_physical_mem_release_params_t type
+/// @brief Print operator for the ur_context_release_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_physical_mem_release_params_t *params) {
-
-    os << ".hPhysicalMem = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_context_release_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phPhysicalMem));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_adapter_get_params_t type
+/// @brief Print operator for the ur_context_get_info_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_adapter_get_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_context_get_info_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ".NumEntries = ";
 
-    os << *(params->pNumEntries);
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << ", ";
-    os << ".phAdapters = {";
-    for (size_t i = 0; *(params->pphAdapters) != NULL && i < *params->pNumEntries; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphAdapters))[i]);
-    }
-    os << "}";
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    os << ", ";
-    os << ".pNumAdapters = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppNumAdapters));
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
+
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
+
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_adapter_release_params_t type
+/// @brief Print operator for the ur_context_get_native_handle_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_adapter_release_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_context_get_native_handle_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
+
 
-    os << ".hAdapter = ";
+        
+    
+        os << ", ";
+        os << ".phNativeContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphNativeContext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phAdapter));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_adapter_retain_params_t type
+/// @brief Print operator for the ur_context_create_with_native_handle_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_adapter_retain_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_context_create_with_native_handle_params_t *params) {
+    
+        
+    
+        os << ".hNativeContext = ";
+        
+        ur::details::printPtr(os, reinterpret_cast<void*>(
+            *(params->phNativeContext)
+        ));
+
+
+        
+    
+        os << ", ";
+        os << ".hAdapter = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phAdapter)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numDevices = ";
+        
+        os << 
+            *(params->pnumDevices)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phDevices = {";
+        for (size_t i = 0; *(params->pphDevices) != NULL && i < *params->pnumDevices; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphDevices))[i]
+            );
+
+        }
+        os << "}";
+
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
 
-    os << ".hAdapter = ";
 
-    ur::details::printPtr(os,
-                          *(params->phAdapter));
+        
+    
+        os << ", ";
+        os << ".phContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphContext)
+        );
+
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_adapter_get_last_error_params_t type
+/// @brief Print operator for the ur_context_set_extended_deleter_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_adapter_get_last_error_params_t *params) {
-
-    os << ".hAdapter = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_context_set_extended_deleter_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phAdapter));
 
-    os << ", ";
-    os << ".ppMessage = ";
+        
+    
+        os << ", ";
+        os << ".pfnDeleter = ";
+        
+        os << reinterpret_cast<void*>(
+            *(params->ppfnDeleter)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pppMessage));
 
-    os << ", ";
-    os << ".pError = ";
+        
+    
+        os << ", ";
+        os << ".pUserData = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppUserData)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppError));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_adapter_get_info_params_t type
+/// @brief Print operator for the ur_event_get_info_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_adapter_get_info_params_t *params) {
-
-    os << ".hAdapter = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_event_get_info_params_t *params) {
+    
+        
+    
+        os << ".hEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phAdapter));
 
-    os << ", ";
-    os << ".propName = ";
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << *(params->ppropName);
 
-    os << ", ";
-    os << ".propSize = ";
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    os << *(params->ppropSize);
 
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".pPropSizeRet = ";
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_kernel_launch_params_t type
+/// @brief Print operator for the ur_event_get_profiling_info_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_kernel_launch_params_t *params) {
-
-    os << ".hQueue = ";
-
-    ur::details::printPtr(os,
-                          *(params->phQueue));
-
-    os << ", ";
-    os << ".hKernel = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_event_get_profiling_info_params_t *params) {
+    
+        
+    
+        os << ".hEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phKernel));
 
-    os << ", ";
-    os << ".workDim = ";
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << *(params->pworkDim);
 
-    os << ", ";
-    os << ".pGlobalWorkOffset = ";
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->ppGlobalWorkOffset));
 
-    os << ", ";
-    os << ".pGlobalWorkSize = ";
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    ur::details::printPtr(os,
-                          *(params->ppGlobalWorkSize));
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    os << ", ";
-    os << ".pLocalWorkSize = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppLocalWorkSize));
+    return os;
+}
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_event_wait_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_event_wait_params_t *params) {
+    
+        
+    
+        os << ".numEvents = ";
+        
+        os << 
+            *(params->pnumEvents)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEvents; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
         }
+        os << "}";
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
+    return os;
+}
 
-    os << ", ";
-    os << ".phEvent = ";
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_event_retain_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_event_retain_params_t *params) {
+    
+        
+    
+        os << ".hEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phEvent)
+        );
+
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_events_wait_params_t type
+/// @brief Print operator for the ur_event_release_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_events_wait_params_t *params) {
-
-    os << ".hQueue = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_event_release_params_t *params) {
+    
+        
+    
+        os << ".hEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+    return os;
+}
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_event_get_native_handle_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_event_get_native_handle_params_t *params) {
+    
+        
+    
+        os << ".hEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phEvent)
+        );
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".phNativeEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphNativeEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_events_wait_with_barrier_params_t type
+/// @brief Print operator for the ur_event_create_with_native_handle_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_events_wait_with_barrier_params_t *params) {
-
-    os << ".hQueue = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_event_create_with_native_handle_params_t *params) {
+    
+        
+    
+        os << ".hNativeEvent = ";
+        
+        ur::details::printPtr(os, reinterpret_cast<void*>(
+            *(params->phNativeEvent)
+        ));
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+        
+    
+        os << ", ";
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_mem_buffer_read_params_t type
+/// @brief Print operator for the ur_event_set_callback_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_buffer_read_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_event_set_callback_params_t *params) {
+    
+        
+    
+        os << ".hEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phEvent)
+        );
 
-    os << ".hQueue = ";
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
+        
+    
+        os << ", ";
+        os << ".execStatus = ";
+        
+        os << 
+            *(params->pexecStatus)
+        ;
 
-    os << ", ";
-    os << ".hBuffer = ";
 
-    ur::details::printPtr(os,
-                          *(params->phBuffer));
+        
+    
+        os << ", ";
+        os << ".pfnNotify = ";
+        
+        os << reinterpret_cast<void*>(
+            *(params->ppfnNotify)
+        );
 
-    os << ", ";
-    os << ".blockingRead = ";
 
-    os << *(params->pblockingRead);
+        
+    
+        os << ", ";
+        os << ".pUserData = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppUserData)
+        );
 
-    os << ", ";
-    os << ".offset = ";
 
-    os << *(params->poffset);
+    return os;
+}
 
-    os << ", ";
-    os << ".size = ";
 
-    os << *(params->psize);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_program_create_with_il_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_create_with_il_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
+
 
-    os << ", ";
-    os << ".pDst = ";
+        
+    
+        os << ", ";
+        os << ".pIL = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppIL)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppDst));
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+        
+    
+        os << ", ";
+        os << ".length = ";
+        
+        os << 
+            *(params->plength)
+        ;
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".phProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphProgram)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_mem_buffer_write_params_t type
+/// @brief Print operator for the ur_program_create_with_binary_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_buffer_write_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_create_with_binary_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ".hQueue = ";
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << ", ";
-    os << ".hBuffer = ";
 
-    ur::details::printPtr(os,
-                          *(params->phBuffer));
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
 
-    os << ", ";
-    os << ".blockingWrite = ";
 
-    os << *(params->pblockingWrite);
+        
+    
+        os << ", ";
+        os << ".pBinary = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppBinary)
+        );
 
-    os << ", ";
-    os << ".offset = ";
 
-    os << *(params->poffset);
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
 
-    os << ", ";
-    os << ".size = ";
 
-    os << *(params->psize);
+        
+    
+        os << ", ";
+        os << ".phProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphProgram)
+        );
+
+
+    return os;
+}
 
-    os << ", ";
-    os << ".pSrc = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppSrc));
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_program_build_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_build_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+        
+    
+        os << ", ";
+        os << ".hProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phProgram)
+        );
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
+        
+    
+        os << ", ";
+        os << ".pOptions = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppOptions)
+        );
+
+
+    return os;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_program_build_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_build_exp_params_t *params) {
+    
+        
+    
+        os << ".hProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phProgram)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numDevices = ";
+        
+        os << 
+            *(params->pnumDevices)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phDevices = {";
+        for (size_t i = 0; *(params->pphDevices) != NULL && i < *params->pnumDevices; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphDevices))[i]
+            );
+
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".pOptions = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppOptions)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_mem_buffer_read_rect_params_t type
+/// @brief Print operator for the ur_program_compile_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_buffer_read_rect_params_t *params) {
-
-    os << ".hQueue = ";
-
-    ur::details::printPtr(os,
-                          *(params->phQueue));
-
-    os << ", ";
-    os << ".hBuffer = ";
-
-    ur::details::printPtr(os,
-                          *(params->phBuffer));
-
-    os << ", ";
-    os << ".blockingRead = ";
-
-    os << *(params->pblockingRead);
-
-    os << ", ";
-    os << ".bufferOrigin = ";
-
-    os << *(params->pbufferOrigin);
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_compile_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ", ";
-    os << ".hostOrigin = ";
 
-    os << *(params->phostOrigin);
+        
+    
+        os << ", ";
+        os << ".hProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phProgram)
+        );
 
-    os << ", ";
-    os << ".region = ";
 
-    os << *(params->pregion);
+        
+    
+        os << ", ";
+        os << ".pOptions = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppOptions)
+        );
 
-    os << ", ";
-    os << ".bufferRowPitch = ";
 
-    os << *(params->pbufferRowPitch);
+    return os;
+}
 
-    os << ", ";
-    os << ".bufferSlicePitch = ";
 
-    os << *(params->pbufferSlicePitch);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_program_compile_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_compile_exp_params_t *params) {
+    
+        
+    
+        os << ".hProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phProgram)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numDevices = ";
+        
+        os << 
+            *(params->pnumDevices)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phDevices = {";
+        for (size_t i = 0; *(params->pphDevices) != NULL && i < *params->pnumDevices; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphDevices))[i]
+            );
 
-    os << ", ";
-    os << ".hostRowPitch = ";
+        }
+        os << "}";
 
-    os << *(params->phostRowPitch);
+        
+    
+        os << ", ";
+        os << ".pOptions = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppOptions)
+        );
 
-    os << ", ";
-    os << ".hostSlicePitch = ";
 
-    os << *(params->phostSlicePitch);
+    return os;
+}
 
-    os << ", ";
-    os << ".pDst = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppDst));
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_program_link_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_link_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".count = ";
+        
+        os << 
+            *(params->pcount)
+        ;
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+        
+    
+        os << ", ";
+        os << ".phPrograms = {";
+        for (size_t i = 0; *(params->pphPrograms) != NULL && i < *params->pcount; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphPrograms))[i]
+            );
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
         }
+        os << "}";
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
+        
+    
+        os << ", ";
+        os << ".pOptions = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppOptions)
+        );
 
-    os << ", ";
-    os << ".phEvent = ";
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
+        
+    
+        os << ", ";
+        os << ".phProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphProgram)
+        );
+
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_mem_buffer_write_rect_params_t type
+/// @brief Print operator for the ur_program_link_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_buffer_write_rect_params_t *params) {
-
-    os << ".hQueue = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_link_exp_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numDevices = ";
+        
+        os << 
+            *(params->pnumDevices)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phDevices = {";
+        for (size_t i = 0; *(params->pphDevices) != NULL && i < *params->pnumDevices; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphDevices))[i]
+            );
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".hBuffer = ";
+        
+    
+        os << ", ";
+        os << ".count = ";
+        
+        os << 
+            *(params->pcount)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->phBuffer));
 
-    os << ", ";
-    os << ".blockingWrite = ";
+        
+    
+        os << ", ";
+        os << ".phPrograms = {";
+        for (size_t i = 0; *(params->pphPrograms) != NULL && i < *params->pcount; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphPrograms))[i]
+            );
 
-    os << *(params->pblockingWrite);
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".bufferOrigin = ";
+        
+    
+        os << ", ";
+        os << ".pOptions = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppOptions)
+        );
 
-    os << *(params->pbufferOrigin);
 
-    os << ", ";
-    os << ".hostOrigin = ";
+        
+    
+        os << ", ";
+        os << ".phProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphProgram)
+        );
 
-    os << *(params->phostOrigin);
 
-    os << ", ";
-    os << ".region = ";
+    return os;
+}
 
-    os << *(params->pregion);
 
-    os << ", ";
-    os << ".bufferRowPitch = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_program_retain_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_retain_params_t *params) {
+    
+        
+    
+        os << ".hProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phProgram)
+        );
 
-    os << *(params->pbufferRowPitch);
 
-    os << ", ";
-    os << ".bufferSlicePitch = ";
+    return os;
+}
 
-    os << *(params->pbufferSlicePitch);
 
-    os << ", ";
-    os << ".hostRowPitch = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_program_release_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_release_params_t *params) {
+    
+        
+    
+        os << ".hProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phProgram)
+        );
 
-    os << *(params->phostRowPitch);
 
-    os << ", ";
-    os << ".hostSlicePitch = ";
+    return os;
+}
 
-    os << *(params->phostSlicePitch);
 
-    os << ", ";
-    os << ".pSrc = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_program_get_function_pointer_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_get_function_pointer_params_t *params) {
+    
+        
+    
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppSrc));
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+        
+    
+        os << ", ";
+        os << ".hProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phProgram)
+        );
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+        
+    
+        os << ", ";
+        os << ".pFunctionName = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppFunctionName)
+        );
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".ppFunctionPointer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pppFunctionPointer)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_mem_buffer_copy_params_t type
+/// @brief Print operator for the ur_program_get_global_variable_pointer_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_buffer_copy_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_get_global_variable_pointer_params_t *params) {
+    
+        
+    
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << ".hQueue = ";
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
+        
+    
+        os << ", ";
+        os << ".hProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phProgram)
+        );
 
-    os << ", ";
-    os << ".hBufferSrc = ";
 
-    ur::details::printPtr(os,
-                          *(params->phBufferSrc));
+        
+    
+        os << ", ";
+        os << ".pGlobalVariableName = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppGlobalVariableName)
+        );
 
-    os << ", ";
-    os << ".hBufferDst = ";
 
-    ur::details::printPtr(os,
-                          *(params->phBufferDst));
+        
+    
+        os << ", ";
+        os << ".pGlobalVariableSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppGlobalVariableSizeRet)
+        );
 
-    os << ", ";
-    os << ".srcOffset = ";
 
-    os << *(params->psrcOffset);
+        
+    
+        os << ", ";
+        os << ".ppGlobalVariablePointerRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pppGlobalVariablePointerRet)
+        );
 
-    os << ", ";
-    os << ".dstOffset = ";
 
-    os << *(params->pdstOffset);
+    return os;
+}
 
-    os << ", ";
-    os << ".size = ";
 
-    os << *(params->psize);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_program_get_info_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_get_info_params_t *params) {
+    
+        
+    
+        os << ".hProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phProgram)
+        );
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
+
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
+
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_mem_buffer_copy_rect_params_t type
+/// @brief Print operator for the ur_program_get_build_info_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_buffer_copy_rect_params_t *params) {
-
-    os << ".hQueue = ";
-
-    ur::details::printPtr(os,
-                          *(params->phQueue));
-
-    os << ", ";
-    os << ".hBufferSrc = ";
-
-    ur::details::printPtr(os,
-                          *(params->phBufferSrc));
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_get_build_info_params_t *params) {
+    
+        
+    
+        os << ".hProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phProgram)
+        );
 
-    os << ", ";
-    os << ".hBufferDst = ";
 
-    ur::details::printPtr(os,
-                          *(params->phBufferDst));
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << ", ";
-    os << ".srcOrigin = ";
 
-    os << *(params->psrcOrigin);
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << ", ";
-    os << ".dstOrigin = ";
 
-    os << *(params->pdstOrigin);
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    os << ", ";
-    os << ".region = ";
 
-    os << *(params->pregion);
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".srcRowPitch = ";
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    os << *(params->psrcRowPitch);
 
-    os << ", ";
-    os << ".srcSlicePitch = ";
+    return os;
+}
 
-    os << *(params->psrcSlicePitch);
 
-    os << ", ";
-    os << ".dstRowPitch = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_program_set_specialization_constants_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_set_specialization_constants_params_t *params) {
+    
+        
+    
+        os << ".hProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phProgram)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".count = ";
+        
+        os << 
+            *(params->pcount)
+        ;
 
-    os << *(params->pdstRowPitch);
 
-    os << ", ";
-    os << ".dstSlicePitch = ";
+        
+    
+        os << ", ";
+        os << ".pSpecConstants = {";
+        for (size_t i = 0; *(params->ppSpecConstants) != NULL && i < *params->pcount; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        os << 
+                (*(params->ppSpecConstants))[i]
+            ;
 
-    os << *(params->pdstSlicePitch);
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+    return os;
+}
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_program_get_native_handle_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_get_native_handle_params_t *params) {
+    
+        
+    
+        os << ".hProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phProgram)
+        );
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".phNativeProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphNativeProgram)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_mem_buffer_fill_params_t type
+/// @brief Print operator for the ur_program_create_with_native_handle_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_buffer_fill_params_t *params) {
-
-    os << ".hQueue = ";
-
-    ur::details::printPtr(os,
-                          *(params->phQueue));
-
-    os << ", ";
-    os << ".hBuffer = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_program_create_with_native_handle_params_t *params) {
+    
+        
+    
+        os << ".hNativeProgram = ";
+        
+        ur::details::printPtr(os, reinterpret_cast<void*>(
+            *(params->phNativeProgram)
+        ));
 
-    ur::details::printPtr(os,
-                          *(params->phBuffer));
 
-    os << ", ";
-    os << ".pPattern = ";
+        
+    
+        os << ", ";
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppPattern));
 
-    os << ", ";
-    os << ".patternSize = ";
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
 
-    os << *(params->ppatternSize);
 
-    os << ", ";
-    os << ".offset = ";
+        
+    
+        os << ", ";
+        os << ".phProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphProgram)
+        );
 
-    os << *(params->poffset);
 
-    os << ", ";
-    os << ".size = ";
+    return os;
+}
 
-    os << *(params->psize);
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_kernel_create_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_create_params_t *params) {
+    
+        
+    
+        os << ".hProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phProgram)
+        );
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+        
+    
+        os << ", ";
+        os << ".pKernelName = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppKernelName)
+        );
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".phKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphKernel)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_mem_image_read_params_t type
+/// @brief Print operator for the ur_kernel_get_info_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_image_read_params_t *params) {
-
-    os << ".hQueue = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_get_info_params_t *params) {
+    
+        
+    
+        os << ".hKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phKernel)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
 
-    os << ", ";
-    os << ".hImage = ";
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->phImage));
 
-    os << ", ";
-    os << ".blockingRead = ";
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    os << *(params->pblockingRead);
 
-    os << ", ";
-    os << ".origin = ";
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << *(params->porigin);
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    os << ", ";
-    os << ".region = ";
 
-    os << *(params->pregion);
+    return os;
+}
 
-    os << ", ";
-    os << ".rowPitch = ";
 
-    os << *(params->prowPitch);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_kernel_get_group_info_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_get_group_info_params_t *params) {
+    
+        
+    
+        os << ".hKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phKernel)
+        );
 
-    os << ", ";
-    os << ".slicePitch = ";
 
-    os << *(params->pslicePitch);
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << ", ";
-    os << ".pDst = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppDst));
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_mem_image_write_params_t type
+/// @brief Print operator for the ur_kernel_get_sub_group_info_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_image_write_params_t *params) {
-
-    os << ".hQueue = ";
-
-    ur::details::printPtr(os,
-                          *(params->phQueue));
-
-    os << ", ";
-    os << ".hImage = ";
-
-    ur::details::printPtr(os,
-                          *(params->phImage));
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_get_sub_group_info_params_t *params) {
+    
+        
+    
+        os << ".hKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phKernel)
+        );
 
-    os << ", ";
-    os << ".blockingWrite = ";
 
-    os << *(params->pblockingWrite);
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << ", ";
-    os << ".origin = ";
 
-    os << *(params->porigin);
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << ", ";
-    os << ".region = ";
 
-    os << *(params->pregion);
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    os << ", ";
-    os << ".rowPitch = ";
 
-    os << *(params->prowPitch);
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".slicePitch = ";
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    os << *(params->pslicePitch);
 
-    os << ", ";
-    os << ".pSrc = ";
+    return os;
+}
 
-    ur::details::printPtr(os,
-                          *(params->ppSrc));
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_kernel_retain_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_retain_params_t *params) {
+    
+        
+    
+        os << ".hKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phKernel)
+        );
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+    return os;
+}
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".phEvent = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_kernel_release_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_release_params_t *params) {
+    
+        
+    
+        os << ".hKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phKernel)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_mem_image_copy_params_t type
+/// @brief Print operator for the ur_kernel_get_native_handle_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_image_copy_params_t *params) {
-
-    os << ".hQueue = ";
-
-    ur::details::printPtr(os,
-                          *(params->phQueue));
-
-    os << ", ";
-    os << ".hImageSrc = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_get_native_handle_params_t *params) {
+    
+        
+    
+        os << ".hKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phKernel)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phImageSrc));
 
-    os << ", ";
-    os << ".hImageDst = ";
+        
+    
+        os << ", ";
+        os << ".phNativeKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphNativeKernel)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phImageDst));
 
-    os << ", ";
-    os << ".srcOrigin = ";
+    return os;
+}
 
-    os << *(params->psrcOrigin);
 
-    os << ", ";
-    os << ".dstOrigin = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_kernel_create_with_native_handle_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_create_with_native_handle_params_t *params) {
+    
+        
+    
+        os << ".hNativeKernel = ";
+        
+        ur::details::printPtr(os, reinterpret_cast<void*>(
+            *(params->phNativeKernel)
+        ));
 
-    os << *(params->pdstOrigin);
 
-    os << ", ";
-    os << ".region = ";
+        
+    
+        os << ", ";
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << *(params->pregion);
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+        
+    
+        os << ", ";
+        os << ".hProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phProgram)
+        );
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".phKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphKernel)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_mem_buffer_map_params_t type
+/// @brief Print operator for the ur_kernel_get_suggested_local_work_size_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_buffer_map_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_get_suggested_local_work_size_params_t *params) {
+    
+        
+    
+        os << ".hKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phKernel)
+        );
 
-    os << ".hQueue = ";
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
+        
+    
+        os << ", ";
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
 
-    os << ", ";
-    os << ".hBuffer = ";
 
-    ur::details::printPtr(os,
-                          *(params->phBuffer));
+        
+    
+        os << ", ";
+        os << ".numWorkDim = ";
+        
+        os << 
+            *(params->pnumWorkDim)
+        ;
 
-    os << ", ";
-    os << ".blockingMap = ";
 
-    os << *(params->pblockingMap);
+        
+    
+        os << ", ";
+        os << ".pGlobalWorkOffset = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppGlobalWorkOffset)
+        );
 
-    os << ", ";
-    os << ".mapFlags = ";
 
-    ur::details::printFlag<ur_map_flag_t>(os,
-                                          *(params->pmapFlags));
+        
+    
+        os << ", ";
+        os << ".pGlobalWorkSize = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppGlobalWorkSize)
+        );
 
-    os << ", ";
-    os << ".offset = ";
 
-    os << *(params->poffset);
+        
+    
+        os << ", ";
+        os << ".pSuggestedLocalWorkSize = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSuggestedLocalWorkSize)
+        );
 
-    os << ", ";
-    os << ".size = ";
 
-    os << *(params->psize);
+    return os;
+}
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_kernel_set_arg_value_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_set_arg_value_params_t *params) {
+    
+        
+    
+        os << ".hKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phKernel)
+        );
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
+        
+    
+        os << ", ";
+        os << ".argIndex = ";
+        
+        os << 
+            *(params->pargIndex)
+        ;
 
-    os << ", ";
-    os << ".phEvent = ";
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
+        
+    
+        os << ", ";
+        os << ".argSize = ";
+        
+        os << 
+            *(params->pargSize)
+        ;
 
-    os << ", ";
-    os << ".ppRetMap = ";
 
-    ur::details::printPtr(os,
-                          *(params->pppRetMap));
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pArgValue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppArgValue)
+        );
+
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_mem_unmap_params_t type
+/// @brief Print operator for the ur_kernel_set_arg_local_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_unmap_params_t *params) {
-
-    os << ".hQueue = ";
-
-    ur::details::printPtr(os,
-                          *(params->phQueue));
-
-    os << ", ";
-    os << ".hMem = ";
-
-    ur::details::printPtr(os,
-                          *(params->phMem));
-
-    os << ", ";
-    os << ".pMappedPtr = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_set_arg_local_params_t *params) {
+    
+        
+    
+        os << ".hKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phKernel)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppMappedPtr));
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+        
+    
+        os << ", ";
+        os << ".argIndex = ";
+        
+        os << 
+            *(params->pargIndex)
+        ;
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+        
+    
+        os << ", ";
+        os << ".argSize = ";
+        
+        os << 
+            *(params->pargSize)
+        ;
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_usm_fill_params_t type
+/// @brief Print operator for the ur_kernel_set_arg_pointer_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_usm_fill_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_set_arg_pointer_params_t *params) {
+    
+        
+    
+        os << ".hKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phKernel)
+        );
+
 
-    os << ".hQueue = ";
+        
+    
+        os << ", ";
+        os << ".argIndex = ";
+        
+        os << 
+            *(params->pargIndex)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
 
-    os << ", ";
-    os << ".pMem = ";
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppMem));
 
-    os << ", ";
-    os << ".patternSize = ";
+        
+    
+        os << ", ";
+        os << ".pArgValue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppArgValue)
+        );
 
-    os << *(params->ppatternSize);
 
-    os << ", ";
-    os << ".pPattern = ";
+    return os;
+}
 
-    ur::details::printPtr(os,
-                          *(params->ppPattern));
 
-    os << ", ";
-    os << ".size = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_kernel_set_exec_info_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_set_exec_info_params_t *params) {
+    
+        
+    
+        os << ".hKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phKernel)
+        );
 
-    os << *(params->psize);
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
+
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_usm_memcpy_params_t type
+/// @brief Print operator for the ur_kernel_set_arg_sampler_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_usm_memcpy_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_set_arg_sampler_params_t *params) {
+    
+        
+    
+        os << ".hKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phKernel)
+        );
 
-    os << ".hQueue = ";
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
+        
+    
+        os << ", ";
+        os << ".argIndex = ";
+        
+        os << 
+            *(params->pargIndex)
+        ;
 
-    os << ", ";
-    os << ".blocking = ";
 
-    os << *(params->pblocking);
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
 
-    os << ", ";
-    os << ".pDst = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppDst));
+        
+    
+        os << ", ";
+        os << ".hArgValue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phArgValue)
+        );
 
-    os << ", ";
-    os << ".pSrc = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppSrc));
+    return os;
+}
 
-    os << ", ";
-    os << ".size = ";
 
-    os << *(params->psize);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_kernel_set_arg_mem_obj_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_set_arg_mem_obj_params_t *params) {
+    
+        
+    
+        os << ".hKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phKernel)
+        );
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+        
+    
+        os << ", ";
+        os << ".argIndex = ";
+        
+        os << 
+            *(params->pargIndex)
+        ;
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
 
-    os << ", ";
-    os << ".phEvent = ";
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
+        
+    
+        os << ", ";
+        os << ".hArgValue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phArgValue)
+        );
+
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_usm_prefetch_params_t type
+/// @brief Print operator for the ur_kernel_set_specialization_constants_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_usm_prefetch_params_t *params) {
-
-    os << ".hQueue = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_set_specialization_constants_params_t *params) {
+    
+        
+    
+        os << ".hKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phKernel)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".count = ";
+        
+        os << 
+            *(params->pcount)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
 
-    os << ", ";
-    os << ".pMem = ";
+        
+    
+        os << ", ";
+        os << ".pSpecConstants = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSpecConstants)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppMem));
 
-    os << ", ";
-    os << ".size = ";
+    return os;
+}
 
-    os << *(params->psize);
 
-    os << ", ";
-    os << ".flags = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_kernel_suggest_max_cooperative_group_count_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_kernel_suggest_max_cooperative_group_count_exp_params_t *params) {
+    
+        
+    
+        os << ".hKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phKernel)
+        );
 
-    ur::details::printFlag<ur_usm_migration_flag_t>(os,
-                                                    *(params->pflags));
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+        
+    
+        os << ", ";
+        os << ".localWorkSize = ";
+        
+        os << 
+            *(params->plocalWorkSize)
+        ;
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+        
+    
+        os << ", ";
+        os << ".dynamicSharedMemorySize = ";
+        
+        os << 
+            *(params->pdynamicSharedMemorySize)
+        ;
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".pGroupCountRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppGroupCountRet)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_usm_advise_params_t type
+/// @brief Print operator for the ur_queue_get_info_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_usm_advise_params_t *params) {
-
-    os << ".hQueue = ";
-
-    ur::details::printPtr(os,
-                          *(params->phQueue));
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_get_info_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
 
-    os << ", ";
-    os << ".pMem = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppMem));
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << ", ";
-    os << ".size = ";
 
-    os << *(params->psize);
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    os << ", ";
-    os << ".advice = ";
 
-    ur::details::printFlag<ur_usm_advice_flag_t>(os,
-                                                 *(params->padvice));
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_usm_fill_2d_params_t type
+/// @brief Print operator for the ur_queue_create_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_usm_fill_2d_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_create_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ".hQueue = ";
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << ", ";
-    os << ".pMem = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppMem));
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
 
-    os << ", ";
-    os << ".pitch = ";
 
-    os << *(params->ppitch);
+        
+    
+        os << ", ";
+        os << ".phQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphQueue)
+        );
 
-    os << ", ";
-    os << ".patternSize = ";
 
-    os << *(params->ppatternSize);
+    return os;
+}
 
-    os << ", ";
-    os << ".pPattern = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppPattern));
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_queue_retain_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_retain_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
 
-    os << ", ";
-    os << ".width = ";
 
-    os << *(params->pwidth);
+    return os;
+}
 
-    os << ", ";
-    os << ".height = ";
 
-    os << *(params->pheight);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_queue_release_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_release_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+    return os;
+}
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_queue_get_native_handle_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_get_native_handle_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pDesc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppDesc)
+        );
 
-    os << ", ";
-    os << ".phEvent = ";
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
+        
+    
+        os << ", ";
+        os << ".phNativeQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphNativeQueue)
+        );
+
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_usm_memcpy_2d_params_t type
+/// @brief Print operator for the ur_queue_create_with_native_handle_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_usm_memcpy_2d_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_create_with_native_handle_params_t *params) {
+    
+        
+    
+        os << ".hNativeQueue = ";
+        
+        ur::details::printPtr(os, reinterpret_cast<void*>(
+            *(params->phNativeQueue)
+        ));
 
-    os << ".hQueue = ";
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
+        
+    
+        os << ", ";
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ", ";
-    os << ".blocking = ";
 
-    os << *(params->pblocking);
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << ", ";
-    os << ".pDst = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppDst));
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
 
-    os << ", ";
-    os << ".dstPitch = ";
 
-    os << *(params->pdstPitch);
+        
+    
+        os << ", ";
+        os << ".phQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphQueue)
+        );
 
-    os << ", ";
-    os << ".pSrc = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppSrc));
+    return os;
+}
 
-    os << ", ";
-    os << ".srcPitch = ";
 
-    os << *(params->psrcPitch);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_queue_finish_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_finish_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
 
-    os << ", ";
-    os << ".width = ";
 
-    os << *(params->pwidth);
+    return os;
+}
 
-    os << ", ";
-    os << ".height = ";
 
-    os << *(params->pheight);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_queue_flush_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_queue_flush_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+    return os;
+}
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_sampler_create_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_sampler_create_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pDesc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppDesc)
+        );
 
-    os << ", ";
-    os << ".phEvent = ";
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
+        
+    
+        os << ", ";
+        os << ".phSampler = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphSampler)
+        );
+
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_device_global_variable_write_params_t type
+/// @brief Print operator for the ur_sampler_retain_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_device_global_variable_write_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_sampler_retain_params_t *params) {
+    
+        
+    
+        os << ".hSampler = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phSampler)
+        );
 
-    os << ".hQueue = ";
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
+    return os;
+}
 
-    os << ", ";
-    os << ".hProgram = ";
 
-    ur::details::printPtr(os,
-                          *(params->phProgram));
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_sampler_release_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_sampler_release_params_t *params) {
+    
+        
+    
+        os << ".hSampler = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phSampler)
+        );
 
-    os << ", ";
-    os << ".name = ";
 
-    ur::details::printPtr(os,
-                          *(params->pname));
+    return os;
+}
 
-    os << ", ";
-    os << ".blockingWrite = ";
 
-    os << *(params->pblockingWrite);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_sampler_get_info_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_sampler_get_info_params_t *params) {
+    
+        
+    
+        os << ".hSampler = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phSampler)
+        );
 
-    os << ", ";
-    os << ".count = ";
 
-    os << *(params->pcount);
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << ", ";
-    os << ".offset = ";
 
-    os << *(params->poffset);
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    os << ", ";
-    os << ".pSrc = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppSrc));
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+    return os;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_sampler_get_native_handle_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_sampler_get_native_handle_params_t *params) {
+    
+        
+    
+        os << ".hSampler = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phSampler)
+        );
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".phNativeSampler = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphNativeSampler)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_device_global_variable_read_params_t type
+/// @brief Print operator for the ur_sampler_create_with_native_handle_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_device_global_variable_read_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_sampler_create_with_native_handle_params_t *params) {
+    
+        
+    
+        os << ".hNativeSampler = ";
+        
+        ur::details::printPtr(os, reinterpret_cast<void*>(
+            *(params->phNativeSampler)
+        ));
+
 
-    os << ".hQueue = ";
+        
+    
+        os << ", ";
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
 
-    os << ", ";
-    os << ".hProgram = ";
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phProgram));
 
-    os << ", ";
-    os << ".name = ";
+        
+    
+        os << ", ";
+        os << ".phSampler = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphSampler)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pname));
 
-    os << ", ";
-    os << ".blockingRead = ";
+    return os;
+}
 
-    os << *(params->pblockingRead);
 
-    os << ", ";
-    os << ".count = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_mem_image_create_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_image_create_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << *(params->pcount);
 
-    os << ", ";
-    os << ".offset = ";
+        
+    
+        os << ", ";
+        os << ".flags = ";
+        
+        ur::details::printFlag<ur_mem_flag_t>(os, 
+            *(params->pflags)
+        );
 
-    os << *(params->poffset);
 
-    os << ", ";
-    os << ".pDst = ";
+        
+    
+        os << ", ";
+        os << ".pImageFormat = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppImageFormat)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppDst));
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+        
+    
+        os << ", ";
+        os << ".pImageDesc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppImageDesc)
+        );
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+        
+    
+        os << ", ";
+        os << ".pHost = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppHost)
+        );
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".phMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphMem)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_read_host_pipe_params_t type
+/// @brief Print operator for the ur_mem_buffer_create_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_read_host_pipe_params_t *params) {
-
-    os << ".hQueue = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_buffer_create_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
 
-    os << ", ";
-    os << ".hProgram = ";
+        
+    
+        os << ", ";
+        os << ".flags = ";
+        
+        ur::details::printFlag<ur_mem_flag_t>(os, 
+            *(params->pflags)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phProgram));
 
-    os << ", ";
-    os << ".pipe_symbol = ";
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->ppipe_symbol));
 
-    os << ", ";
-    os << ".blocking = ";
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
 
-    os << *(params->pblocking);
 
-    os << ", ";
-    os << ".pDst = ";
+        
+    
+        os << ", ";
+        os << ".phBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphBuffer)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppDst));
 
-    os << ", ";
-    os << ".size = ";
+    return os;
+}
 
-    os << *(params->psize);
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_mem_retain_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_retain_params_t *params) {
+    
+        
+    
+        os << ".hMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phMem)
+        );
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+    return os;
+}
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".phEvent = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_mem_release_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_release_params_t *params) {
+    
+        
+    
+        os << ".hMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phMem)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_write_host_pipe_params_t type
+/// @brief Print operator for the ur_mem_buffer_partition_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_write_host_pipe_params_t *params) {
-
-    os << ".hQueue = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_buffer_partition_params_t *params) {
+    
+        
+    
+        os << ".hBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phBuffer)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
 
-    os << ", ";
-    os << ".hProgram = ";
+        
+    
+        os << ", ";
+        os << ".flags = ";
+        
+        ur::details::printFlag<ur_mem_flag_t>(os, 
+            *(params->pflags)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phProgram));
 
-    os << ", ";
-    os << ".pipe_symbol = ";
+        
+    
+        os << ", ";
+        os << ".bufferCreateType = ";
+        
+        os << 
+            *(params->pbufferCreateType)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->ppipe_symbol));
 
-    os << ", ";
-    os << ".blocking = ";
+        
+    
+        os << ", ";
+        os << ".pRegion = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppRegion)
+        );
 
-    os << *(params->pblocking);
 
-    os << ", ";
-    os << ".pSrc = ";
+        
+    
+        os << ", ";
+        os << ".phMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphMem)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppSrc));
 
-    os << ", ";
-    os << ".size = ";
+    return os;
+}
 
-    os << *(params->psize);
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_mem_get_native_handle_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_get_native_handle_params_t *params) {
+    
+        
+    
+        os << ".hMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phMem)
+        );
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".phNativeMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphNativeMem)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_kernel_launch_custom_exp_params_t type
+/// @brief Print operator for the ur_mem_buffer_create_with_native_handle_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_kernel_launch_custom_exp_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_buffer_create_with_native_handle_params_t *params) {
+    
+        
+    
+        os << ".hNativeMem = ";
+        
+        ur::details::printPtr(os, reinterpret_cast<void*>(
+            *(params->phNativeMem)
+        ));
 
-    os << ".hQueue = ";
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
+        
+    
+        os << ", ";
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ", ";
-    os << ".hKernel = ";
 
-    ur::details::printPtr(os,
-                          *(params->phKernel));
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
 
-    os << ", ";
-    os << ".workDim = ";
 
-    os << *(params->pworkDim);
+        
+    
+        os << ", ";
+        os << ".phMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphMem)
+        );
 
-    os << ", ";
-    os << ".pGlobalWorkSize = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppGlobalWorkSize));
+    return os;
+}
 
-    os << ", ";
-    os << ".pLocalWorkSize = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppLocalWorkSize));
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_mem_image_create_with_native_handle_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_image_create_with_native_handle_params_t *params) {
+    
+        
+    
+        os << ".hNativeMem = ";
+        
+        ur::details::printPtr(os, reinterpret_cast<void*>(
+            *(params->phNativeMem)
+        ));
 
-    os << ", ";
-    os << ".numPropsInLaunchPropList = ";
 
-    os << *(params->pnumPropsInLaunchPropList);
+        
+    
+        os << ", ";
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ", ";
-    os << ".launchPropList = {";
-    for (size_t i = 0; *(params->plaunchPropList) != NULL && i < *params->pnumPropsInLaunchPropList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        os << (*(params->plaunchPropList))[i];
-    }
-    os << "}";
+        
+    
+        os << ", ";
+        os << ".pImageFormat = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppImageFormat)
+        );
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+        
+    
+        os << ", ";
+        os << ".pImageDesc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppImageDesc)
+        );
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
+
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".phMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphMem)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_cooperative_kernel_launch_exp_params_t type
+/// @brief Print operator for the ur_mem_get_info_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_cooperative_kernel_launch_exp_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_get_info_params_t *params) {
+    
+        
+    
+        os << ".hMemory = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phMemory)
+        );
 
-    os << ".hQueue = ";
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << ", ";
-    os << ".hKernel = ";
 
-    ur::details::printPtr(os,
-                          *(params->phKernel));
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    os << ", ";
-    os << ".workDim = ";
 
-    os << *(params->pworkDim);
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".pGlobalWorkOffset = ";
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppGlobalWorkOffset));
 
-    os << ", ";
-    os << ".pGlobalWorkSize = ";
+    return os;
+}
 
-    ur::details::printPtr(os,
-                          *(params->ppGlobalWorkSize));
 
-    os << ", ";
-    os << ".pLocalWorkSize = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_mem_image_get_info_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_mem_image_get_info_params_t *params) {
+    
+        
+    
+        os << ".hMemory = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phMemory)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppLocalWorkSize));
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
+
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_timestamp_recording_exp_params_t type
+/// @brief Print operator for the ur_physical_mem_create_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_timestamp_recording_exp_params_t *params) {
-
-    os << ".hQueue = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_physical_mem_create_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phQueue));
 
-    os << ", ";
-    os << ".blocking = ";
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << *(params->pblocking);
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".phPhysicalMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphPhysicalMem)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_enqueue_native_command_exp_params_t type
+/// @brief Print operator for the ur_physical_mem_retain_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_native_command_exp_params_t *params) {
-
-    os << ".hQueue = ";
-
-    ur::details::printPtr(os,
-                          *(params->phQueue));
-
-    os << ", ";
-    os << ".pfnNativeEnqueue = ";
-
-    os << reinterpret_cast<void *>(
-        *(params->ppfnNativeEnqueue));
-
-    os << ", ";
-    os << ".data = ";
-
-    ur::details::printPtr(os,
-                          *(params->pdata));
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_physical_mem_retain_params_t *params) {
+    
+        
+    
+        os << ".hPhysicalMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phPhysicalMem)
+        );
 
-    os << ", ";
-    os << ".numMemsInMemList = ";
 
-    os << *(params->pnumMemsInMemList);
+    return os;
+}
 
-    os << ", ";
-    os << ".phMemList = {";
-    for (size_t i = 0; *(params->pphMemList) != NULL && i < *params->pnumMemsInMemList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphMemList))[i]);
-    }
-    os << "}";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_physical_mem_release_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_physical_mem_release_params_t *params) {
+    
+        
+    
+        os << ".hPhysicalMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phPhysicalMem)
+        );
 
-    os << ", ";
-    os << ".pProperties = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
+    return os;
+}
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_adapter_get_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_adapter_get_params_t *params) {
+    
+        
+    
+        os << ".NumEntries = ";
+        
+        os << 
+            *(params->pNumEntries)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phAdapters = {";
+        for (size_t i = 0; *(params->pphAdapters) != NULL && i < *params->pNumEntries; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphAdapters))[i]
+            );
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
         }
+        os << "}";
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
-
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".pNumAdapters = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppNumAdapters)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_bindless_images_unsampled_image_handle_destroy_exp_params_t type
+/// @brief Print operator for the ur_adapter_release_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_unsampled_image_handle_destroy_exp_params_t *params) {
-
-    os << ".hContext = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_adapter_release_params_t *params) {
+    
+        
+    
+        os << ".hAdapter = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phAdapter)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
 
-    os << ", ";
-    os << ".hDevice = ";
+    return os;
+}
 
-    ur::details::printPtr(os,
-                          *(params->phDevice));
 
-    os << ", ";
-    os << ".hImage = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_adapter_retain_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_adapter_retain_params_t *params) {
+    
+        
+    
+        os << ".hAdapter = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phAdapter)
+        );
 
-    ur::details::printPtr(os, reinterpret_cast<void *>(
-                                  *(params->phImage)));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_bindless_images_sampled_image_handle_destroy_exp_params_t type
+/// @brief Print operator for the ur_adapter_get_last_error_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_sampled_image_handle_destroy_exp_params_t *params) {
-
-    os << ".hContext = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_adapter_get_last_error_params_t *params) {
+    
+        
+    
+        os << ".hAdapter = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phAdapter)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
 
-    os << ", ";
-    os << ".hDevice = ";
+        
+    
+        os << ", ";
+        os << ".ppMessage = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pppMessage)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phDevice));
 
-    os << ", ";
-    os << ".hImage = ";
+        
+    
+        os << ", ";
+        os << ".pError = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppError)
+        );
 
-    ur::details::printPtr(os, reinterpret_cast<void *>(
-                                  *(params->phImage)));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_bindless_images_image_allocate_exp_params_t type
+/// @brief Print operator for the ur_adapter_get_info_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_image_allocate_exp_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_adapter_get_info_params_t *params) {
+    
+        
+    
+        os << ".hAdapter = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phAdapter)
+        );
 
-    os << ", ";
-    os << ".hDevice = ";
 
-    ur::details::printPtr(os,
-                          *(params->phDevice));
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << ", ";
-    os << ".pImageFormat = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppImageFormat));
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    os << ", ";
-    os << ".pImageDesc = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppImageDesc));
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".phImageMem = ";
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphImageMem));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_bindless_images_image_free_exp_params_t type
+/// @brief Print operator for the ur_enqueue_kernel_launch_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_image_free_exp_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".hDevice = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_kernel_launch_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phKernel)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".workDim = ";
+        
+        os << 
+            *(params->pworkDim)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pGlobalWorkOffset = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppGlobalWorkOffset)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pGlobalWorkSize = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppGlobalWorkSize)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pLocalWorkSize = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppLocalWorkSize)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    ur::details::printPtr(os,
-                          *(params->phDevice));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".hImageMem = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os, reinterpret_cast<void *>(
-                                  *(params->phImageMem)));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_bindless_images_unsampled_image_create_exp_params_t type
+/// @brief Print operator for the ur_enqueue_events_wait_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_unsampled_image_create_exp_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".hDevice = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_events_wait_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    ur::details::printPtr(os,
-                          *(params->phDevice));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".hImageMem = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os, reinterpret_cast<void *>(
-                                  *(params->phImageMem)));
 
-    os << ", ";
-    os << ".pImageFormat = ";
+    return os;
+}
 
-    ur::details::printPtr(os,
-                          *(params->ppImageFormat));
 
-    os << ", ";
-    os << ".pImageDesc = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_enqueue_events_wait_with_barrier_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_events_wait_with_barrier_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    ur::details::printPtr(os,
-                          *(params->ppImageDesc));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".phImage = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphImage));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_bindless_images_sampled_image_create_exp_params_t type
+/// @brief Print operator for the ur_enqueue_mem_buffer_read_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_sampled_image_create_exp_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_buffer_read_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".blockingRead = ";
+        
+        os << 
+            *(params->pblockingRead)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".offset = ";
+        
+        os << 
+            *(params->poffset)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pDst = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppDst)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
+
+        }
+        os << "}";
 
-    os << ".hContext = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
 
-    os << ", ";
-    os << ".hDevice = ";
+    return os;
+}
 
-    ur::details::printPtr(os,
-                          *(params->phDevice));
 
-    os << ", ";
-    os << ".hImageMem = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_enqueue_mem_buffer_write_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_buffer_write_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".blockingWrite = ";
+        
+        os << 
+            *(params->pblockingWrite)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".offset = ";
+        
+        os << 
+            *(params->poffset)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pSrc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSrc)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    ur::details::printPtr(os, reinterpret_cast<void *>(
-                                  *(params->phImageMem)));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".pImageFormat = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppImageFormat));
 
-    os << ", ";
-    os << ".pImageDesc = ";
+    return os;
+}
 
-    ur::details::printPtr(os,
-                          *(params->ppImageDesc));
 
-    os << ", ";
-    os << ".hSampler = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_enqueue_mem_buffer_read_rect_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_buffer_read_rect_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".blockingRead = ";
+        
+        os << 
+            *(params->pblockingRead)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".bufferOrigin = ";
+        
+        os << 
+            *(params->pbufferOrigin)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".hostOrigin = ";
+        
+        os << 
+            *(params->phostOrigin)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".region = ";
+        
+        os << 
+            *(params->pregion)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".bufferRowPitch = ";
+        
+        os << 
+            *(params->pbufferRowPitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".bufferSlicePitch = ";
+        
+        os << 
+            *(params->pbufferSlicePitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".hostRowPitch = ";
+        
+        os << 
+            *(params->phostRowPitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".hostSlicePitch = ";
+        
+        os << 
+            *(params->phostSlicePitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pDst = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppDst)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    ur::details::printPtr(os,
-                          *(params->phSampler));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".phImage = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphImage));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_bindless_images_image_copy_exp_params_t type
+/// @brief Print operator for the ur_enqueue_mem_buffer_write_rect_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_image_copy_exp_params_t *params) {
-
-    os << ".hQueue = ";
-
-    ur::details::printPtr(os,
-                          *(params->phQueue));
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_buffer_write_rect_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".blockingWrite = ";
+        
+        os << 
+            *(params->pblockingWrite)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".bufferOrigin = ";
+        
+        os << 
+            *(params->pbufferOrigin)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".hostOrigin = ";
+        
+        os << 
+            *(params->phostOrigin)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".region = ";
+        
+        os << 
+            *(params->pregion)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".bufferRowPitch = ";
+        
+        os << 
+            *(params->pbufferRowPitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".bufferSlicePitch = ";
+        
+        os << 
+            *(params->pbufferSlicePitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".hostRowPitch = ";
+        
+        os << 
+            *(params->phostRowPitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".hostSlicePitch = ";
+        
+        os << 
+            *(params->phostSlicePitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pSrc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSrc)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".pSrc = ";
+        }
+        os << "}";
 
-    ur::details::printPtr(os,
-                          *(params->ppSrc));
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    os << ", ";
-    os << ".pDst = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppDst));
+    return os;
+}
 
-    os << ", ";
-    os << ".pSrcImageDesc = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppSrcImageDesc));
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_enqueue_mem_buffer_copy_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_buffer_copy_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hBufferSrc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phBufferSrc)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hBufferDst = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phBufferDst)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".srcOffset = ";
+        
+        os << 
+            *(params->psrcOffset)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".dstOffset = ";
+        
+        os << 
+            *(params->pdstOffset)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".pDstImageDesc = ";
+        }
+        os << "}";
 
-    ur::details::printPtr(os,
-                          *(params->ppDstImageDesc));
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    os << ", ";
-    os << ".pSrcImageFormat = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppSrcImageFormat));
+    return os;
+}
 
-    os << ", ";
-    os << ".pDstImageFormat = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppDstImageFormat));
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_enqueue_mem_buffer_copy_rect_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_buffer_copy_rect_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hBufferSrc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phBufferSrc)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hBufferDst = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phBufferDst)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".srcOrigin = ";
+        
+        os << 
+            *(params->psrcOrigin)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".dstOrigin = ";
+        
+        os << 
+            *(params->pdstOrigin)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".region = ";
+        
+        os << 
+            *(params->pregion)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".srcRowPitch = ";
+        
+        os << 
+            *(params->psrcRowPitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".srcSlicePitch = ";
+        
+        os << 
+            *(params->psrcSlicePitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".dstRowPitch = ";
+        
+        os << 
+            *(params->pdstRowPitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".dstSlicePitch = ";
+        
+        os << 
+            *(params->pdstSlicePitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".pCopyRegion = ";
+        }
+        os << "}";
 
-    ur::details::printPtr(os,
-                          *(params->ppCopyRegion));
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    os << ", ";
-    os << ".imageCopyFlags = ";
 
-    ur::details::printFlag<ur_exp_image_copy_flag_t>(os,
-                                                     *(params->pimageCopyFlags));
+    return os;
+}
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_enqueue_mem_buffer_fill_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_buffer_fill_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pPattern = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPattern)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".patternSize = ";
+        
+        os << 
+            *(params->ppatternSize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".offset = ";
+        
+        os << 
+            *(params->poffset)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
         }
+        os << "}";
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
-
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_bindless_images_image_get_info_exp_params_t type
+/// @brief Print operator for the ur_enqueue_mem_image_read_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_image_get_info_exp_params_t *params) {
-
-    os << ".hContext = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_image_read_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hImage = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phImage)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".blockingRead = ";
+        
+        os << 
+            *(params->pblockingRead)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".origin = ";
+        
+        os << 
+            *(params->porigin)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".region = ";
+        
+        os << 
+            *(params->pregion)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".rowPitch = ";
+        
+        os << 
+            *(params->prowPitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".slicePitch = ";
+        
+        os << 
+            *(params->pslicePitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pDst = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppDst)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".hImageMem = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os, reinterpret_cast<void *>(
-                                  *(params->phImageMem)));
 
-    os << ", ";
-    os << ".propName = ";
+    return os;
+}
 
-    os << *(params->ppropName);
 
-    os << ", ";
-    os << ".pPropValue = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_enqueue_mem_image_write_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_image_write_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hImage = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phImage)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".blockingWrite = ";
+        
+        os << 
+            *(params->pblockingWrite)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".origin = ";
+        
+        os << 
+            *(params->porigin)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".region = ";
+        
+        os << 
+            *(params->pregion)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".rowPitch = ";
+        
+        os << 
+            *(params->prowPitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".slicePitch = ";
+        
+        os << 
+            *(params->pslicePitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pSrc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSrc)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    ur::details::printPtr(os,
-                          *(params->ppPropValue));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".pPropSizeRet = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_bindless_images_mipmap_get_level_exp_params_t type
+/// @brief Print operator for the ur_enqueue_mem_image_copy_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_mipmap_get_level_exp_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_image_copy_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hImageSrc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phImageSrc)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hImageDst = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phImageDst)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".srcOrigin = ";
+        
+        os << 
+            *(params->psrcOrigin)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".dstOrigin = ";
+        
+        os << 
+            *(params->pdstOrigin)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".region = ";
+        
+        os << 
+            *(params->pregion)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
+
+        }
+        os << "}";
 
-    os << ".hContext = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
 
-    os << ", ";
-    os << ".hDevice = ";
+    return os;
+}
 
-    ur::details::printPtr(os,
-                          *(params->phDevice));
 
-    os << ", ";
-    os << ".hImageMem = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_enqueue_mem_buffer_map_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_buffer_map_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".blockingMap = ";
+        
+        os << 
+            *(params->pblockingMap)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".mapFlags = ";
+        
+        ur::details::printFlag<ur_map_flag_t>(os, 
+            *(params->pmapFlags)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".offset = ";
+        
+        os << 
+            *(params->poffset)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    ur::details::printPtr(os, reinterpret_cast<void *>(
-                                  *(params->phImageMem)));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".mipmapLevel = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    os << *(params->pmipmapLevel);
 
-    os << ", ";
-    os << ".phImageMem = ";
+        
+    
+        os << ", ";
+        os << ".ppRetMap = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pppRetMap)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphImageMem));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_bindless_images_mipmap_free_exp_params_t type
+/// @brief Print operator for the ur_enqueue_mem_unmap_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_mipmap_free_exp_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".hDevice = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_mem_unmap_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phMem)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pMappedPtr = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppMappedPtr)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    ur::details::printPtr(os,
-                          *(params->phDevice));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".hMem = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os, reinterpret_cast<void *>(
-                                  *(params->phMem)));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_bindless_images_import_external_memory_exp_params_t type
+/// @brief Print operator for the ur_enqueue_usm_fill_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_import_external_memory_exp_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_usm_fill_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppMem)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".patternSize = ";
+        
+        os << 
+            *(params->ppatternSize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pPattern = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPattern)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
+
+        }
+        os << "}";
+
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    os << ".hContext = ";
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
+    return os;
+}
+
 
-    os << ", ";
-    os << ".hDevice = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_enqueue_usm_memcpy_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_usm_memcpy_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".blocking = ";
+        
+        os << 
+            *(params->pblocking)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pDst = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppDst)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pSrc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSrc)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    ur::details::printPtr(os,
-                          *(params->phDevice));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".size = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    os << *(params->psize);
 
-    os << ", ";
-    os << ".memHandleType = ";
+    return os;
+}
 
-    os << *(params->pmemHandleType);
 
-    os << ", ";
-    os << ".pExternalMemDesc = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_enqueue_usm_prefetch_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_usm_prefetch_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppMem)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".flags = ";
+        
+        ur::details::printFlag<ur_usm_migration_flag_t>(os, 
+            *(params->pflags)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    ur::details::printPtr(os,
-                          *(params->ppExternalMemDesc));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".phExternalMem = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphExternalMem));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_bindless_images_map_external_array_exp_params_t type
+/// @brief Print operator for the ur_enqueue_usm_advise_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_map_external_array_exp_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".hDevice = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_usm_advise_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phDevice));
 
-    os << ", ";
-    os << ".pImageFormat = ";
+        
+    
+        os << ", ";
+        os << ".pMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppMem)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppImageFormat));
 
-    os << ", ";
-    os << ".pImageDesc = ";
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->ppImageDesc));
 
-    os << ", ";
-    os << ".hExternalMem = ";
+        
+    
+        os << ", ";
+        os << ".advice = ";
+        
+        ur::details::printFlag<ur_usm_advice_flag_t>(os, 
+            *(params->padvice)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phExternalMem));
 
-    os << ", ";
-    os << ".phImageMem = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphImageMem));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_bindless_images_map_external_linear_memory_exp_params_t type
+/// @brief Print operator for the ur_enqueue_usm_fill_2d_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_map_external_linear_memory_exp_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".hDevice = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_usm_fill_2d_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppMem)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pitch = ";
+        
+        os << 
+            *(params->ppitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".patternSize = ";
+        
+        os << 
+            *(params->ppatternSize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pPattern = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPattern)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".width = ";
+        
+        os << 
+            *(params->pwidth)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".height = ";
+        
+        os << 
+            *(params->pheight)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    ur::details::printPtr(os,
-                          *(params->phDevice));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".offset = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    os << *(params->poffset);
 
-    os << ", ";
-    os << ".size = ";
+    return os;
+}
 
-    os << *(params->psize);
 
-    os << ", ";
-    os << ".hExternalMem = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_enqueue_usm_memcpy_2d_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_usm_memcpy_2d_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".blocking = ";
+        
+        os << 
+            *(params->pblocking)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pDst = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppDst)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".dstPitch = ";
+        
+        os << 
+            *(params->pdstPitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pSrc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSrc)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".srcPitch = ";
+        
+        os << 
+            *(params->psrcPitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".width = ";
+        
+        os << 
+            *(params->pwidth)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".height = ";
+        
+        os << 
+            *(params->pheight)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    ur::details::printPtr(os,
-                          *(params->phExternalMem));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".ppRetMem = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pppRetMem));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_bindless_images_release_external_memory_exp_params_t type
+/// @brief Print operator for the ur_enqueue_device_global_variable_write_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_release_external_memory_exp_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".hDevice = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_device_global_variable_write_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phProgram)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".name = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pname)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".blockingWrite = ";
+        
+        os << 
+            *(params->pblockingWrite)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".count = ";
+        
+        os << 
+            *(params->pcount)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".offset = ";
+        
+        os << 
+            *(params->poffset)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pSrc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSrc)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    ur::details::printPtr(os,
-                          *(params->phDevice));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".hExternalMem = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phExternalMem));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_bindless_images_import_external_semaphore_exp_params_t type
+/// @brief Print operator for the ur_enqueue_device_global_variable_read_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_import_external_semaphore_exp_params_t *params) {
-
-    os << ".hContext = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_device_global_variable_read_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phProgram)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".name = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pname)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".blockingRead = ";
+        
+        os << 
+            *(params->pblockingRead)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".count = ";
+        
+        os << 
+            *(params->pcount)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".offset = ";
+        
+        os << 
+            *(params->poffset)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pDst = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppDst)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".hDevice = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phDevice));
 
-    os << ", ";
-    os << ".semHandleType = ";
+    return os;
+}
 
-    os << *(params->psemHandleType);
 
-    os << ", ";
-    os << ".pExternalSemaphoreDesc = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_enqueue_read_host_pipe_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_read_host_pipe_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phProgram)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pipe_symbol = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppipe_symbol)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".blocking = ";
+        
+        os << 
+            *(params->pblocking)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pDst = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppDst)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    ur::details::printPtr(os,
-                          *(params->ppExternalSemaphoreDesc));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".phExternalSemaphore = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphExternalSemaphore));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_bindless_images_release_external_semaphore_exp_params_t type
+/// @brief Print operator for the ur_enqueue_write_host_pipe_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_release_external_semaphore_exp_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".hDevice = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_write_host_pipe_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hProgram = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phProgram)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pipe_symbol = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppipe_symbol)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".blocking = ";
+        
+        os << 
+            *(params->pblocking)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pSrc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSrc)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    ur::details::printPtr(os,
-                          *(params->phDevice));
+        }
+        os << "}";
 
-    os << ", ";
-    os << ".hExternalSemaphore = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phExternalSemaphore));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_bindless_images_wait_external_semaphore_exp_params_t type
+/// @brief Print operator for the ur_enqueue_kernel_launch_custom_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_wait_external_semaphore_exp_params_t *params) {
-
-    os << ".hQueue = ";
-
-    ur::details::printPtr(os,
-                          *(params->phQueue));
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_kernel_launch_custom_exp_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phKernel)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".workDim = ";
+        
+        os << 
+            *(params->pworkDim)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pGlobalWorkSize = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppGlobalWorkSize)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pLocalWorkSize = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppLocalWorkSize)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numPropsInLaunchPropList = ";
+        
+        os << 
+            *(params->pnumPropsInLaunchPropList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".launchPropList = {";
+        for (size_t i = 0; *(params->plaunchPropList) != NULL && i < *params->pnumPropsInLaunchPropList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        os << 
+                (*(params->plaunchPropList))[i]
+            ;
 
-    os << ", ";
-    os << ".hSemaphore = ";
+        }
+        os << "}";
 
-    ur::details::printPtr(os,
-                          *(params->phSemaphore));
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".hasWaitValue = ";
+        }
+        os << "}";
 
-    os << *(params->phasWaitValue);
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    os << ", ";
-    os << ".waitValue = ";
 
-    os << *(params->pwaitValue);
+    return os;
+}
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_enqueue_cooperative_kernel_launch_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_cooperative_kernel_launch_exp_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phKernel)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".workDim = ";
+        
+        os << 
+            *(params->pworkDim)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pGlobalWorkOffset = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppGlobalWorkOffset)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pGlobalWorkSize = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppGlobalWorkSize)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pLocalWorkSize = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppLocalWorkSize)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
         }
+        os << "}";
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
-
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_bindless_images_signal_external_semaphore_exp_params_t type
+/// @brief Print operator for the ur_enqueue_timestamp_recording_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_signal_external_semaphore_exp_params_t *params) {
-
-    os << ".hQueue = ";
-
-    ur::details::printPtr(os,
-                          *(params->phQueue));
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_timestamp_recording_exp_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".blocking = ";
+        
+        os << 
+            *(params->pblocking)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".hSemaphore = ";
+        }
+        os << "}";
 
-    ur::details::printPtr(os,
-                          *(params->phSemaphore));
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    os << ", ";
-    os << ".hasSignalValue = ";
 
-    os << *(params->phasSignalValue);
+    return os;
+}
 
-    os << ", ";
-    os << ".signalValue = ";
 
-    os << *(params->psignalValue);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_enqueue_native_command_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_enqueue_native_command_exp_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pfnNativeEnqueue = ";
+        
+        os << reinterpret_cast<void*>(
+            *(params->ppfnNativeEnqueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".data = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pdata)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numMemsInMemList = ";
+        
+        os << 
+            *(params->pnumMemsInMemList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phMemList = {";
+        for (size_t i = 0; *(params->pphMemList) != NULL && i < *params->pnumMemsInMemList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphMemList))[i]
+            );
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+        }
+        os << "}";
 
-    os << *(params->pnumEventsInWaitList);
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
         }
+        os << "}";
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
-
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_host_alloc_params_t type
+/// @brief Print operator for the ur_bindless_images_unsampled_image_handle_destroy_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_host_alloc_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".pUSMDesc = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppUSMDesc));
-
-    os << ", ";
-    os << ".pool = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_unsampled_image_handle_destroy_exp_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppool));
 
-    os << ", ";
-    os << ".size = ";
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << *(params->psize);
 
-    os << ", ";
-    os << ".ppMem = ";
+        
+    
+        os << ", ";
+        os << ".hImage = ";
+        
+        ur::details::printPtr(os, reinterpret_cast<void*>(
+            *(params->phImage)
+        ));
 
-    ur::details::printPtr(os,
-                          *(params->pppMem));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_device_alloc_params_t type
+/// @brief Print operator for the ur_bindless_images_sampled_image_handle_destroy_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_device_alloc_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".hDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->phDevice));
-
-    os << ", ";
-    os << ".pUSMDesc = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppUSMDesc));
-
-    os << ", ";
-    os << ".pool = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_sampled_image_handle_destroy_exp_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppool));
 
-    os << ", ";
-    os << ".size = ";
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << *(params->psize);
 
-    os << ", ";
-    os << ".ppMem = ";
+        
+    
+        os << ", ";
+        os << ".hImage = ";
+        
+        ur::details::printPtr(os, reinterpret_cast<void*>(
+            *(params->phImage)
+        ));
 
-    ur::details::printPtr(os,
-                          *(params->pppMem));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_shared_alloc_params_t type
+/// @brief Print operator for the ur_bindless_images_image_allocate_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_shared_alloc_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".hDevice = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_image_allocate_exp_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phDevice));
 
-    os << ", ";
-    os << ".pUSMDesc = ";
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppUSMDesc));
 
-    os << ", ";
-    os << ".pool = ";
+        
+    
+        os << ", ";
+        os << ".pImageFormat = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppImageFormat)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppool));
 
-    os << ", ";
-    os << ".size = ";
+        
+    
+        os << ", ";
+        os << ".pImageDesc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppImageDesc)
+        );
 
-    os << *(params->psize);
 
-    os << ", ";
-    os << ".ppMem = ";
+        
+    
+        os << ", ";
+        os << ".phImageMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphImageMem)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pppMem));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_free_params_t type
+/// @brief Print operator for the ur_bindless_images_image_free_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_free_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_image_free_exp_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ".hContext = ";
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << ", ";
-    os << ".pMem = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppMem));
+        
+    
+        os << ", ";
+        os << ".hImageMem = ";
+        
+        ur::details::printPtr(os, reinterpret_cast<void*>(
+            *(params->phImageMem)
+        ));
+
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_get_mem_alloc_info_params_t type
+/// @brief Print operator for the ur_bindless_images_unsampled_image_create_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_get_mem_alloc_info_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_unsampled_image_create_exp_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ".hContext = ";
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << ", ";
-    os << ".pMem = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppMem));
+        
+    
+        os << ", ";
+        os << ".hImageMem = ";
+        
+        ur::details::printPtr(os, reinterpret_cast<void*>(
+            *(params->phImageMem)
+        ));
 
-    os << ", ";
-    os << ".propName = ";
 
-    os << *(params->ppropName);
+        
+    
+        os << ", ";
+        os << ".pImageFormat = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppImageFormat)
+        );
 
-    os << ", ";
-    os << ".propSize = ";
 
-    os << *(params->ppropSize);
+        
+    
+        os << ", ";
+        os << ".pImageDesc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppImageDesc)
+        );
 
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".pPropSizeRet = ";
+        
+    
+        os << ", ";
+        os << ".phImage = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphImage)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_pool_create_params_t type
+/// @brief Print operator for the ur_bindless_images_sampled_image_create_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_pool_create_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_sampled_image_create_exp_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ".hContext = ";
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << ", ";
-    os << ".pPoolDesc = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppPoolDesc));
+        
+    
+        os << ", ";
+        os << ".hImageMem = ";
+        
+        ur::details::printPtr(os, reinterpret_cast<void*>(
+            *(params->phImageMem)
+        ));
 
-    os << ", ";
-    os << ".ppPool = ";
 
-    ur::details::printPtr(os,
-                          *(params->pppPool));
+        
+    
+        os << ", ";
+        os << ".pImageFormat = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppImageFormat)
+        );
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_pool_retain_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_pool_retain_params_t *params) {
+        
+    
+        os << ", ";
+        os << ".pImageDesc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppImageDesc)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hSampler = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phSampler)
+        );
 
-    os << ".pPool = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppPool));
+        
+    
+        os << ", ";
+        os << ".phImage = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphImage)
+        );
+
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_pool_release_params_t type
+/// @brief Print operator for the ur_bindless_images_image_copy_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_pool_release_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_image_copy_exp_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pSrc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSrc)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pDst = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppDst)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pSrcImageDesc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSrcImageDesc)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pDstImageDesc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppDstImageDesc)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pSrcImageFormat = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSrcImageFormat)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pDstImageFormat = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppDstImageFormat)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pCopyRegion = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppCopyRegion)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".imageCopyFlags = ";
+        
+        ur::details::printFlag<ur_exp_image_copy_flag_t>(os, 
+            *(params->pimageCopyFlags)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
+
+        }
+        os << "}";
 
-    os << ".pPool = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppPool));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_pool_get_info_params_t type
+/// @brief Print operator for the ur_bindless_images_image_get_info_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_pool_get_info_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_image_get_info_exp_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ".hPool = ";
 
-    ur::details::printPtr(os,
-                          *(params->phPool));
+        
+    
+        os << ", ";
+        os << ".hImageMem = ";
+        
+        ur::details::printPtr(os, reinterpret_cast<void*>(
+            *(params->phImageMem)
+        ));
 
-    os << ", ";
-    os << ".propName = ";
 
-    os << *(params->ppropName);
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << ", ";
-    os << ".propSize = ";
 
-    os << *(params->ppropSize);
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropValue)
+        );
 
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".pPropSizeRet = ";
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_pitched_alloc_exp_params_t type
+/// @brief Print operator for the ur_bindless_images_mipmap_get_level_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_pitched_alloc_exp_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".hDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->phDevice));
-
-    os << ", ";
-    os << ".pUSMDesc = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppUSMDesc));
-
-    os << ", ";
-    os << ".pool = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppool));
-
-    os << ", ";
-    os << ".widthInBytes = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_mipmap_get_level_exp_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << *(params->pwidthInBytes);
 
-    os << ", ";
-    os << ".height = ";
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << *(params->pheight);
 
-    os << ", ";
-    os << ".elementSizeBytes = ";
+        
+    
+        os << ", ";
+        os << ".hImageMem = ";
+        
+        ur::details::printPtr(os, reinterpret_cast<void*>(
+            *(params->phImageMem)
+        ));
 
-    os << *(params->pelementSizeBytes);
 
-    os << ", ";
-    os << ".ppMem = ";
+        
+    
+        os << ", ";
+        os << ".mipmapLevel = ";
+        
+        os << 
+            *(params->pmipmapLevel)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->pppMem));
 
-    os << ", ";
-    os << ".pResultPitch = ";
+        
+    
+        os << ", ";
+        os << ".phImageMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphImageMem)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppResultPitch));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_import_exp_params_t type
+/// @brief Print operator for the ur_bindless_images_mipmap_free_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_import_exp_params_t *params) {
-
-    os << ".hContext = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_mipmap_free_exp_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
 
-    os << ", ";
-    os << ".pMem = ";
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppMem));
 
-    os << ", ";
-    os << ".size = ";
+        
+    
+        os << ", ";
+        os << ".hMem = ";
+        
+        ur::details::printPtr(os, reinterpret_cast<void*>(
+            *(params->phMem)
+        ));
 
-    os << *(params->psize);
 
     return os;
 }
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_usm_release_exp_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_release_exp_params_t *params) {
-
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
-
-    os << ", ";
-    os << ".pMem = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppMem));
-
-    return os;
-}
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_command_buffer_create_exp_params_t type
+/// @brief Print operator for the ur_bindless_images_import_external_memory_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_create_exp_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_import_external_memory_exp_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
+
 
-    os << ".hContext = ";
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->phContext));
 
-    os << ", ";
-    os << ".hDevice = ";
+        
+    
+        os << ", ";
+        os << ".memHandleType = ";
+        
+        os << 
+            *(params->pmemHandleType)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->phDevice));
 
-    os << ", ";
-    os << ".pCommandBufferDesc = ";
+        
+    
+        os << ", ";
+        os << ".pExternalMemDesc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppExternalMemDesc)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppCommandBufferDesc));
 
-    os << ", ";
-    os << ".phCommandBuffer = ";
+        
+    
+        os << ", ";
+        os << ".phExternalMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphExternalMem)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphCommandBuffer));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_command_buffer_retain_exp_params_t type
+/// @brief Print operator for the ur_bindless_images_map_external_array_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_retain_exp_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_map_external_array_exp_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ".hCommandBuffer = ";
 
-    ur::details::printPtr(os,
-                          *(params->phCommandBuffer));
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_command_buffer_release_exp_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_release_exp_params_t *params) {
+        
+    
+        os << ", ";
+        os << ".pImageFormat = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppImageFormat)
+        );
 
-    os << ".hCommandBuffer = ";
 
-    ur::details::printPtr(os,
-                          *(params->phCommandBuffer));
+        
+    
+        os << ", ";
+        os << ".pImageDesc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppImageDesc)
+        );
 
-    return os;
-}
 
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_command_buffer_finalize_exp_params_t type
-/// @returns
-///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_finalize_exp_params_t *params) {
+        
+    
+        os << ", ";
+        os << ".hExternalMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phExternalMem)
+        );
+
 
-    os << ".hCommandBuffer = ";
+        
+    
+        os << ", ";
+        os << ".phImageMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphImageMem)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phCommandBuffer));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_command_buffer_append_kernel_launch_exp_params_t type
+/// @brief Print operator for the ur_bindless_images_map_external_linear_memory_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_kernel_launch_exp_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_map_external_linear_memory_exp_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
+
 
-    os << ".hCommandBuffer = ";
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phCommandBuffer));
 
-    os << ", ";
-    os << ".hKernel = ";
+        
+    
+        os << ", ";
+        os << ".offset = ";
+        
+        os << 
+            *(params->poffset)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->phKernel));
 
-    os << ", ";
-    os << ".workDim = ";
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
 
-    os << *(params->pworkDim);
 
-    os << ", ";
-    os << ".pGlobalWorkOffset = ";
+        
+    
+        os << ", ";
+        os << ".hExternalMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phExternalMem)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppGlobalWorkOffset));
 
-    os << ", ";
-    os << ".pGlobalWorkSize = ";
+        
+    
+        os << ", ";
+        os << ".ppRetMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pppRetMem)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppGlobalWorkSize));
 
-    os << ", ";
-    os << ".pLocalWorkSize = ";
+    return os;
+}
 
-    ur::details::printPtr(os,
-                          *(params->ppLocalWorkSize));
 
-    os << ", ";
-    os << ".numKernelAlternatives = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_bindless_images_release_external_memory_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_release_external_memory_exp_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << *(params->pnumKernelAlternatives);
 
-    os << ", ";
-    os << ".phKernelAlternatives = {";
-    for (size_t i = 0; *(params->pphKernelAlternatives) != NULL && i < *params->pnumKernelAlternatives; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-        ur::details::printPtr(os,
-                              (*(params->pphKernelAlternatives))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".numSyncPointsInWaitList = ";
+        
+    
+        os << ", ";
+        os << ".hExternalMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phExternalMem)
+        );
 
-    os << *(params->pnumSyncPointsInWaitList);
 
-    os << ", ";
-    os << ".pSyncPointWaitList = ";
+    return os;
+}
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPointWaitList));
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_bindless_images_import_external_semaphore_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_import_external_semaphore_exp_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".pSyncPoint = ";
+        
+    
+        os << ", ";
+        os << ".semHandleType = ";
+        
+        os << 
+            *(params->psemHandleType)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPoint));
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".pExternalSemaphoreDesc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppExternalSemaphoreDesc)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
-    os << ", ";
-    os << ".phCommand = ";
+        
+    
+        os << ", ";
+        os << ".phExternalSemaphore = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphExternalSemaphore)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphCommand));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_command_buffer_append_usm_memcpy_exp_params_t type
+/// @brief Print operator for the ur_bindless_images_release_external_semaphore_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_usm_memcpy_exp_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_release_external_semaphore_exp_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ".hCommandBuffer = ";
 
-    ur::details::printPtr(os,
-                          *(params->phCommandBuffer));
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << ", ";
-    os << ".pDst = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppDst));
+        
+    
+        os << ", ";
+        os << ".hExternalSemaphore = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phExternalSemaphore)
+        );
 
-    os << ", ";
-    os << ".pSrc = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppSrc));
+    return os;
+}
 
-    os << ", ";
-    os << ".size = ";
 
-    os << *(params->psize);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_bindless_images_wait_external_semaphore_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_wait_external_semaphore_exp_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hSemaphore = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phSemaphore)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hasWaitValue = ";
+        
+        os << 
+            *(params->phasWaitValue)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".waitValue = ";
+        
+        os << 
+            *(params->pwaitValue)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".numSyncPointsInWaitList = ";
+        }
+        os << "}";
 
-    os << *(params->pnumSyncPointsInWaitList);
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    os << ", ";
-    os << ".pSyncPointWaitList = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPointWaitList));
+    return os;
+}
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_bindless_images_signal_external_semaphore_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_bindless_images_signal_external_semaphore_exp_params_t *params) {
+    
+        
+    
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hSemaphore = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phSemaphore)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hasSignalValue = ";
+        
+        os << 
+            *(params->phasSignalValue)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".signalValue = ";
+        
+        os << 
+            *(params->psignalValue)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
         }
+        os << "}";
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
-
-    os << ", ";
-    os << ".pSyncPoint = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppSyncPoint));
-
-    os << ", ";
-    os << ".phEvent = ";
-
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
-
-    os << ", ";
-    os << ".phCommand = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphCommand));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_command_buffer_append_usm_fill_exp_params_t type
+/// @brief Print operator for the ur_usm_host_alloc_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_usm_fill_exp_params_t *params) {
-
-    os << ".hCommandBuffer = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_host_alloc_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phCommandBuffer));
 
-    os << ", ";
-    os << ".pMemory = ";
+        
+    
+        os << ", ";
+        os << ".pUSMDesc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppUSMDesc)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppMemory));
 
-    os << ", ";
-    os << ".pPattern = ";
+        
+    
+        os << ", ";
+        os << ".pool = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppool)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppPattern));
 
-    os << ", ";
-    os << ".patternSize = ";
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
 
-    os << *(params->ppatternSize);
 
-    os << ", ";
-    os << ".size = ";
+        
+    
+        os << ", ";
+        os << ".ppMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pppMem)
+        );
 
-    os << *(params->psize);
 
-    os << ", ";
-    os << ".numSyncPointsInWaitList = ";
+    return os;
+}
 
-    os << *(params->pnumSyncPointsInWaitList);
 
-    os << ", ";
-    os << ".pSyncPointWaitList = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_usm_device_alloc_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_device_alloc_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPointWaitList));
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+        
+    
+        os << ", ";
+        os << ".pUSMDesc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppUSMDesc)
+        );
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".pSyncPoint = ";
+        
+    
+        os << ", ";
+        os << ".pool = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppool)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPoint));
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
-    os << ", ";
-    os << ".phCommand = ";
+        
+    
+        os << ", ";
+        os << ".ppMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pppMem)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphCommand));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_command_buffer_append_mem_buffer_copy_exp_params_t type
+/// @brief Print operator for the ur_usm_shared_alloc_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_mem_buffer_copy_exp_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_shared_alloc_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << ".hCommandBuffer = ";
 
-    ur::details::printPtr(os,
-                          *(params->phCommandBuffer));
+        
+    
+        os << ", ";
+        os << ".pUSMDesc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppUSMDesc)
+        );
 
-    os << ", ";
-    os << ".hSrcMem = ";
 
-    ur::details::printPtr(os,
-                          *(params->phSrcMem));
+        
+    
+        os << ", ";
+        os << ".pool = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppool)
+        );
 
-    os << ", ";
-    os << ".hDstMem = ";
 
-    ur::details::printPtr(os,
-                          *(params->phDstMem));
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
 
-    os << ", ";
-    os << ".srcOffset = ";
 
-    os << *(params->psrcOffset);
+        
+    
+        os << ", ";
+        os << ".ppMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pppMem)
+        );
+
+
+    return os;
+}
 
-    os << ", ";
-    os << ".dstOffset = ";
 
-    os << *(params->pdstOffset);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_usm_free_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_free_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ", ";
-    os << ".size = ";
 
-    os << *(params->psize);
+        
+    
+        os << ", ";
+        os << ".pMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppMem)
+        );
 
-    os << ", ";
-    os << ".numSyncPointsInWaitList = ";
 
-    os << *(params->pnumSyncPointsInWaitList);
+    return os;
+}
 
-    os << ", ";
-    os << ".pSyncPointWaitList = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPointWaitList));
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_usm_get_mem_alloc_info_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_get_mem_alloc_info_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+        
+    
+        os << ", ";
+        os << ".pMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppMem)
+        );
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << ", ";
-    os << ".pSyncPoint = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPoint));
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    os << ", ";
-    os << ".phEvent = ";
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".phCommand = ";
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphCommand));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_command_buffer_append_mem_buffer_write_exp_params_t type
+/// @brief Print operator for the ur_usm_pool_create_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_mem_buffer_write_exp_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_pool_create_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ".hCommandBuffer = ";
 
-    ur::details::printPtr(os,
-                          *(params->phCommandBuffer));
+        
+    
+        os << ", ";
+        os << ".pPoolDesc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPoolDesc)
+        );
 
-    os << ", ";
-    os << ".hBuffer = ";
 
-    ur::details::printPtr(os,
-                          *(params->phBuffer));
+        
+    
+        os << ", ";
+        os << ".ppPool = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pppPool)
+        );
 
-    os << ", ";
-    os << ".offset = ";
 
-    os << *(params->poffset);
+    return os;
+}
 
-    os << ", ";
-    os << ".size = ";
 
-    os << *(params->psize);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_usm_pool_retain_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_pool_retain_params_t *params) {
+    
+        
+    
+        os << ".pPool = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPool)
+        );
 
-    os << ", ";
-    os << ".pSrc = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppSrc));
+    return os;
+}
 
-    os << ", ";
-    os << ".numSyncPointsInWaitList = ";
 
-    os << *(params->pnumSyncPointsInWaitList);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_usm_pool_release_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_pool_release_params_t *params) {
+    
+        
+    
+        os << ".pPool = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPool)
+        );
 
-    os << ", ";
-    os << ".pSyncPointWaitList = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPointWaitList));
+    return os;
+}
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_usm_pool_get_info_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_pool_get_info_params_t *params) {
+    
+        
+    
+        os << ".hPool = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phPool)
+        );
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << ", ";
-    os << ".pSyncPoint = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPoint));
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    os << ", ";
-    os << ".phEvent = ";
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".phCommand = ";
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphCommand));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_command_buffer_append_mem_buffer_read_exp_params_t type
+/// @brief Print operator for the ur_usm_pitched_alloc_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_mem_buffer_read_exp_params_t *params) {
-
-    os << ".hCommandBuffer = ";
-
-    ur::details::printPtr(os,
-                          *(params->phCommandBuffer));
-
-    os << ", ";
-    os << ".hBuffer = ";
-
-    ur::details::printPtr(os,
-                          *(params->phBuffer));
-
-    os << ", ";
-    os << ".offset = ";
-
-    os << *(params->poffset);
-
-    os << ", ";
-    os << ".size = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_pitched_alloc_exp_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << *(params->psize);
 
-    os << ", ";
-    os << ".pDst = ";
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppDst));
 
-    os << ", ";
-    os << ".numSyncPointsInWaitList = ";
+        
+    
+        os << ", ";
+        os << ".pUSMDesc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppUSMDesc)
+        );
 
-    os << *(params->pnumSyncPointsInWaitList);
 
-    os << ", ";
-    os << ".pSyncPointWaitList = ";
+        
+    
+        os << ", ";
+        os << ".pool = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppool)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPointWaitList));
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+        
+    
+        os << ", ";
+        os << ".widthInBytes = ";
+        
+        os << 
+            *(params->pwidthInBytes)
+        ;
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+        
+    
+        os << ", ";
+        os << ".height = ";
+        
+        os << 
+            *(params->pheight)
+        ;
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".pSyncPoint = ";
+        
+    
+        os << ", ";
+        os << ".elementSizeBytes = ";
+        
+        os << 
+            *(params->pelementSizeBytes)
+        ;
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPoint));
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".ppMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pppMem)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
-    os << ", ";
-    os << ".phCommand = ";
+        
+    
+        os << ", ";
+        os << ".pResultPitch = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppResultPitch)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphCommand));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_command_buffer_append_mem_buffer_copy_rect_exp_params_t type
+/// @brief Print operator for the ur_usm_import_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_mem_buffer_copy_rect_exp_params_t *params) {
-
-    os << ".hCommandBuffer = ";
-
-    ur::details::printPtr(os,
-                          *(params->phCommandBuffer));
-
-    os << ", ";
-    os << ".hSrcMem = ";
-
-    ur::details::printPtr(os,
-                          *(params->phSrcMem));
-
-    os << ", ";
-    os << ".hDstMem = ";
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_import_exp_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phDstMem));
 
-    os << ", ";
-    os << ".srcOrigin = ";
+        
+    
+        os << ", ";
+        os << ".pMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppMem)
+        );
 
-    os << *(params->psrcOrigin);
 
-    os << ", ";
-    os << ".dstOrigin = ";
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
 
-    os << *(params->pdstOrigin);
 
-    os << ", ";
-    os << ".region = ";
+    return os;
+}
 
-    os << *(params->pregion);
 
-    os << ", ";
-    os << ".srcRowPitch = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_usm_release_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_release_exp_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << *(params->psrcRowPitch);
 
-    os << ", ";
-    os << ".srcSlicePitch = ";
+        
+    
+        os << ", ";
+        os << ".pMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppMem)
+        );
 
-    os << *(params->psrcSlicePitch);
 
-    os << ", ";
-    os << ".dstRowPitch = ";
+    return os;
+}
 
-    os << *(params->pdstRowPitch);
 
-    os << ", ";
-    os << ".dstSlicePitch = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_command_buffer_create_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_create_exp_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << *(params->pdstSlicePitch);
 
-    os << ", ";
-    os << ".numSyncPointsInWaitList = ";
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << *(params->pnumSyncPointsInWaitList);
 
-    os << ", ";
-    os << ".pSyncPointWaitList = ";
+        
+    
+        os << ", ";
+        os << ".pCommandBufferDesc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppCommandBufferDesc)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPointWaitList));
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
+        
+    
+        os << ", ";
+        os << ".phCommandBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphCommandBuffer)
+        );
 
-    os << *(params->pnumEventsInWaitList);
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
-        }
+    return os;
+}
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
 
-    os << ", ";
-    os << ".pSyncPoint = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_command_buffer_retain_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_retain_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommandBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommandBuffer)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPoint));
 
-    os << ", ";
-    os << ".phEvent = ";
+    return os;
+}
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
-    os << ", ";
-    os << ".phCommand = ";
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_command_buffer_release_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_release_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommandBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommandBuffer)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphCommand));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_command_buffer_append_mem_buffer_write_rect_exp_params_t type
+/// @brief Print operator for the ur_command_buffer_finalize_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_mem_buffer_write_rect_exp_params_t *params) {
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_finalize_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommandBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommandBuffer)
+        );
 
-    os << ".hCommandBuffer = ";
 
-    ur::details::printPtr(os,
-                          *(params->phCommandBuffer));
+    return os;
+}
 
-    os << ", ";
-    os << ".hBuffer = ";
 
-    ur::details::printPtr(os,
-                          *(params->phBuffer));
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_command_buffer_append_kernel_launch_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_kernel_launch_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommandBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommandBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hKernel = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phKernel)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".workDim = ";
+        
+        os << 
+            *(params->pworkDim)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pGlobalWorkOffset = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppGlobalWorkOffset)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pGlobalWorkSize = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppGlobalWorkSize)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pLocalWorkSize = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppLocalWorkSize)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numKernelAlternatives = ";
+        
+        os << 
+            *(params->pnumKernelAlternatives)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phKernelAlternatives = {";
+        for (size_t i = 0; *(params->pphKernelAlternatives) != NULL && i < *params->pnumKernelAlternatives; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphKernelAlternatives))[i]
+            );
 
-    os << ", ";
-    os << ".bufferOffset = ";
+        }
+        os << "}";
 
-    os << *(params->pbufferOffset);
+        
+    
+        os << ", ";
+        os << ".numSyncPointsInWaitList = ";
+        
+        os << 
+            *(params->pnumSyncPointsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pSyncPointWaitList = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPointWaitList)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".hostOffset = ";
+        }
+        os << "}";
 
-    os << *(params->phostOffset);
+        
+    
+        os << ", ";
+        os << ".pSyncPoint = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPoint)
+        );
 
-    os << ", ";
-    os << ".region = ";
 
-    os << *(params->pregion);
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    os << ", ";
-    os << ".bufferRowPitch = ";
 
-    os << *(params->pbufferRowPitch);
+        
+    
+        os << ", ";
+        os << ".phCommand = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphCommand)
+        );
 
-    os << ", ";
-    os << ".bufferSlicePitch = ";
 
-    os << *(params->pbufferSlicePitch);
+    return os;
+}
 
-    os << ", ";
-    os << ".hostRowPitch = ";
 
-    os << *(params->phostRowPitch);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_command_buffer_append_usm_memcpy_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_usm_memcpy_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommandBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommandBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pDst = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppDst)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pSrc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSrc)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numSyncPointsInWaitList = ";
+        
+        os << 
+            *(params->pnumSyncPointsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pSyncPointWaitList = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPointWaitList)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".hostSlicePitch = ";
+        }
+        os << "}";
 
-    os << *(params->phostSlicePitch);
+        
+    
+        os << ", ";
+        os << ".pSyncPoint = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPoint)
+        );
 
-    os << ", ";
-    os << ".pSrc = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppSrc));
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    os << ", ";
-    os << ".numSyncPointsInWaitList = ";
 
-    os << *(params->pnumSyncPointsInWaitList);
+        
+    
+        os << ", ";
+        os << ".phCommand = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphCommand)
+        );
 
-    os << ", ";
-    os << ".pSyncPointWaitList = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPointWaitList));
+    return os;
+}
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_command_buffer_append_usm_fill_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_usm_fill_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommandBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommandBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pMemory = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppMemory)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pPattern = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPattern)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".patternSize = ";
+        
+        os << 
+            *(params->ppatternSize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numSyncPointsInWaitList = ";
+        
+        os << 
+            *(params->pnumSyncPointsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pSyncPointWaitList = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPointWaitList)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
         }
+        os << "}";
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
-
-    os << ", ";
-    os << ".pSyncPoint = ";
+        
+    
+        os << ", ";
+        os << ".pSyncPoint = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPoint)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPoint));
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
-    os << ", ";
-    os << ".phCommand = ";
+        
+    
+        os << ", ";
+        os << ".phCommand = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphCommand)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphCommand));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_command_buffer_append_mem_buffer_read_rect_exp_params_t type
+/// @brief Print operator for the ur_command_buffer_append_mem_buffer_copy_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_mem_buffer_read_rect_exp_params_t *params) {
-
-    os << ".hCommandBuffer = ";
-
-    ur::details::printPtr(os,
-                          *(params->phCommandBuffer));
-
-    os << ", ";
-    os << ".hBuffer = ";
-
-    ur::details::printPtr(os,
-                          *(params->phBuffer));
-
-    os << ", ";
-    os << ".bufferOffset = ";
-
-    os << *(params->pbufferOffset);
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_mem_buffer_copy_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommandBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommandBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hSrcMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phSrcMem)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hDstMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDstMem)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".srcOffset = ";
+        
+        os << 
+            *(params->psrcOffset)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".dstOffset = ";
+        
+        os << 
+            *(params->pdstOffset)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numSyncPointsInWaitList = ";
+        
+        os << 
+            *(params->pnumSyncPointsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pSyncPointWaitList = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPointWaitList)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".hostOffset = ";
+        }
+        os << "}";
 
-    os << *(params->phostOffset);
+        
+    
+        os << ", ";
+        os << ".pSyncPoint = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPoint)
+        );
 
-    os << ", ";
-    os << ".region = ";
 
-    os << *(params->pregion);
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    os << ", ";
-    os << ".bufferRowPitch = ";
 
-    os << *(params->pbufferRowPitch);
+        
+    
+        os << ", ";
+        os << ".phCommand = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphCommand)
+        );
 
-    os << ", ";
-    os << ".bufferSlicePitch = ";
 
-    os << *(params->pbufferSlicePitch);
+    return os;
+}
 
-    os << ", ";
-    os << ".hostRowPitch = ";
 
-    os << *(params->phostRowPitch);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_command_buffer_append_mem_buffer_write_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_mem_buffer_write_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommandBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommandBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".offset = ";
+        
+        os << 
+            *(params->poffset)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pSrc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSrc)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numSyncPointsInWaitList = ";
+        
+        os << 
+            *(params->pnumSyncPointsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pSyncPointWaitList = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPointWaitList)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".hostSlicePitch = ";
+        }
+        os << "}";
 
-    os << *(params->phostSlicePitch);
+        
+    
+        os << ", ";
+        os << ".pSyncPoint = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPoint)
+        );
 
-    os << ", ";
-    os << ".pDst = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppDst));
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    os << ", ";
-    os << ".numSyncPointsInWaitList = ";
 
-    os << *(params->pnumSyncPointsInWaitList);
+        
+    
+        os << ", ";
+        os << ".phCommand = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphCommand)
+        );
 
-    os << ", ";
-    os << ".pSyncPointWaitList = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPointWaitList));
+    return os;
+}
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_command_buffer_append_mem_buffer_read_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_mem_buffer_read_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommandBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommandBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".offset = ";
+        
+        os << 
+            *(params->poffset)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pDst = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppDst)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numSyncPointsInWaitList = ";
+        
+        os << 
+            *(params->pnumSyncPointsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pSyncPointWaitList = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPointWaitList)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
         }
+        os << "}";
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
-
-    os << ", ";
-    os << ".pSyncPoint = ";
+        
+    
+        os << ", ";
+        os << ".pSyncPoint = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPoint)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPoint));
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
-    os << ", ";
-    os << ".phCommand = ";
+        
+    
+        os << ", ";
+        os << ".phCommand = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphCommand)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphCommand));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_command_buffer_append_mem_buffer_fill_exp_params_t type
+/// @brief Print operator for the ur_command_buffer_append_mem_buffer_copy_rect_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_mem_buffer_fill_exp_params_t *params) {
-
-    os << ".hCommandBuffer = ";
-
-    ur::details::printPtr(os,
-                          *(params->phCommandBuffer));
-
-    os << ", ";
-    os << ".hBuffer = ";
-
-    ur::details::printPtr(os,
-                          *(params->phBuffer));
-
-    os << ", ";
-    os << ".pPattern = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppPattern));
-
-    os << ", ";
-    os << ".patternSize = ";
-
-    os << *(params->ppatternSize);
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_mem_buffer_copy_rect_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommandBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommandBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hSrcMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phSrcMem)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hDstMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDstMem)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".srcOrigin = ";
+        
+        os << 
+            *(params->psrcOrigin)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".dstOrigin = ";
+        
+        os << 
+            *(params->pdstOrigin)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".region = ";
+        
+        os << 
+            *(params->pregion)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".srcRowPitch = ";
+        
+        os << 
+            *(params->psrcRowPitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".srcSlicePitch = ";
+        
+        os << 
+            *(params->psrcSlicePitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".dstRowPitch = ";
+        
+        os << 
+            *(params->pdstRowPitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".dstSlicePitch = ";
+        
+        os << 
+            *(params->pdstSlicePitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numSyncPointsInWaitList = ";
+        
+        os << 
+            *(params->pnumSyncPointsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pSyncPointWaitList = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPointWaitList)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".offset = ";
+        }
+        os << "}";
 
-    os << *(params->poffset);
+        
+    
+        os << ", ";
+        os << ".pSyncPoint = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPoint)
+        );
 
-    os << ", ";
-    os << ".size = ";
 
-    os << *(params->psize);
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    os << ", ";
-    os << ".numSyncPointsInWaitList = ";
 
-    os << *(params->pnumSyncPointsInWaitList);
+        
+    
+        os << ", ";
+        os << ".phCommand = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphCommand)
+        );
 
-    os << ", ";
-    os << ".pSyncPointWaitList = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPointWaitList));
+    return os;
+}
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_command_buffer_append_mem_buffer_write_rect_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_mem_buffer_write_rect_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommandBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommandBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".bufferOffset = ";
+        
+        os << 
+            *(params->pbufferOffset)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".hostOffset = ";
+        
+        os << 
+            *(params->phostOffset)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".region = ";
+        
+        os << 
+            *(params->pregion)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".bufferRowPitch = ";
+        
+        os << 
+            *(params->pbufferRowPitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".bufferSlicePitch = ";
+        
+        os << 
+            *(params->pbufferSlicePitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".hostRowPitch = ";
+        
+        os << 
+            *(params->phostRowPitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".hostSlicePitch = ";
+        
+        os << 
+            *(params->phostSlicePitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pSrc = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSrc)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numSyncPointsInWaitList = ";
+        
+        os << 
+            *(params->pnumSyncPointsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pSyncPointWaitList = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPointWaitList)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
         }
+        os << "}";
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
-
-    os << ", ";
-    os << ".pSyncPoint = ";
+        
+    
+        os << ", ";
+        os << ".pSyncPoint = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPoint)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPoint));
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
-    os << ", ";
-    os << ".phCommand = ";
+        
+    
+        os << ", ";
+        os << ".phCommand = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphCommand)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphCommand));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_command_buffer_append_usm_prefetch_exp_params_t type
+/// @brief Print operator for the ur_command_buffer_append_mem_buffer_read_rect_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_usm_prefetch_exp_params_t *params) {
-
-    os << ".hCommandBuffer = ";
-
-    ur::details::printPtr(os,
-                          *(params->phCommandBuffer));
-
-    os << ", ";
-    os << ".pMemory = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppMemory));
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_mem_buffer_read_rect_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommandBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommandBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".bufferOffset = ";
+        
+        os << 
+            *(params->pbufferOffset)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".hostOffset = ";
+        
+        os << 
+            *(params->phostOffset)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".region = ";
+        
+        os << 
+            *(params->pregion)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".bufferRowPitch = ";
+        
+        os << 
+            *(params->pbufferRowPitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".bufferSlicePitch = ";
+        
+        os << 
+            *(params->pbufferSlicePitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".hostRowPitch = ";
+        
+        os << 
+            *(params->phostRowPitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".hostSlicePitch = ";
+        
+        os << 
+            *(params->phostSlicePitch)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pDst = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppDst)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numSyncPointsInWaitList = ";
+        
+        os << 
+            *(params->pnumSyncPointsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pSyncPointWaitList = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPointWaitList)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".size = ";
+        }
+        os << "}";
 
-    os << *(params->psize);
+        
+    
+        os << ", ";
+        os << ".pSyncPoint = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPoint)
+        );
 
-    os << ", ";
-    os << ".flags = ";
 
-    ur::details::printFlag<ur_usm_migration_flag_t>(os,
-                                                    *(params->pflags));
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    os << ", ";
-    os << ".numSyncPointsInWaitList = ";
 
-    os << *(params->pnumSyncPointsInWaitList);
+        
+    
+        os << ", ";
+        os << ".phCommand = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphCommand)
+        );
 
-    os << ", ";
-    os << ".pSyncPointWaitList = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPointWaitList));
+    return os;
+}
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_command_buffer_append_mem_buffer_fill_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_mem_buffer_fill_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommandBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommandBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pPattern = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPattern)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".patternSize = ";
+        
+        os << 
+            *(params->ppatternSize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".offset = ";
+        
+        os << 
+            *(params->poffset)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".numSyncPointsInWaitList = ";
+        
+        os << 
+            *(params->pnumSyncPointsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pSyncPointWaitList = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPointWaitList)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
         }
+        os << "}";
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
-
-    os << ", ";
-    os << ".pSyncPoint = ";
+        
+    
+        os << ", ";
+        os << ".pSyncPoint = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPoint)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPoint));
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
-    os << ", ";
-    os << ".phCommand = ";
+        
+    
+        os << ", ";
+        os << ".phCommand = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphCommand)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphCommand));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_command_buffer_append_usm_advise_exp_params_t type
+/// @brief Print operator for the ur_command_buffer_append_usm_prefetch_exp_params_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_usm_advise_exp_params_t *params) {
-
-    os << ".hCommandBuffer = ";
-
-    ur::details::printPtr(os,
-                          *(params->phCommandBuffer));
-
-    os << ", ";
-    os << ".pMemory = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppMemory));
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_usm_prefetch_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommandBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommandBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pMemory = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppMemory)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".flags = ";
+        
+        ur::details::printFlag<ur_usm_migration_flag_t>(os, 
+            *(params->pflags)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numSyncPointsInWaitList = ";
+        
+        os << 
+            *(params->pnumSyncPointsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pSyncPointWaitList = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPointWaitList)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".size = ";
+        }
+        os << "}";
 
-    os << *(params->psize);
+        
+    
+        os << ", ";
+        os << ".pSyncPoint = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPoint)
+        );
 
-    os << ", ";
-    os << ".advice = ";
 
-    ur::details::printFlag<ur_usm_advice_flag_t>(os,
-                                                 *(params->padvice));
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    os << ", ";
-    os << ".numSyncPointsInWaitList = ";
 
-    os << *(params->pnumSyncPointsInWaitList);
+        
+    
+        os << ", ";
+        os << ".phCommand = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphCommand)
+        );
 
-    os << ", ";
-    os << ".pSyncPointWaitList = ";
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPointWaitList));
+    return os;
+}
 
-    os << ", ";
-    os << ".numEventsInWaitList = ";
 
-    os << *(params->pnumEventsInWaitList);
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Print operator for the ur_command_buffer_append_usm_advise_exp_params_t type
+/// @returns
+///     std::ostream &
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_append_usm_advise_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommandBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommandBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pMemory = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppMemory)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".advice = ";
+        
+        ur::details::printFlag<ur_usm_advice_flag_t>(os, 
+            *(params->padvice)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numSyncPointsInWaitList = ";
+        
+        os << 
+            *(params->pnumSyncPointsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".pSyncPointWaitList = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPointWaitList)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
         }
+        os << "}";
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
-
-    os << ", ";
-    os << ".pSyncPoint = ";
+        
+    
+        os << ", ";
+        os << ".pSyncPoint = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSyncPoint)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppSyncPoint));
 
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
-    os << ", ";
-    os << ".phCommand = ";
+        
+    
+        os << ", ";
+        os << ".phCommand = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphCommand)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphCommand));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_command_buffer_enqueue_exp_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_enqueue_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommandBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommandBuffer)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".hQueue = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phQueue)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ".hCommandBuffer = ";
-
-    ur::details::printPtr(os,
-                          *(params->phCommandBuffer));
-
-    os << ", ";
-    os << ".hQueue = ";
-
-    ur::details::printPtr(os,
-                          *(params->phQueue));
-
-    os << ", ";
-    os << ".numEventsInWaitList = ";
-
-    os << *(params->pnumEventsInWaitList);
-
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
         }
+        os << "}";
 
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
-
-    os << ", ";
-    os << ".phEvent = ";
+        
+    
+        os << ", ";
+        os << ".phEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_command_buffer_retain_command_exp_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_retain_command_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommand = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommand)
+        );
 
-    os << ".hCommand = ";
-
-    ur::details::printPtr(os,
-                          *(params->phCommand));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_command_buffer_release_command_exp_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_release_command_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommand = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommand)
+        );
 
-    os << ".hCommand = ";
-
-    ur::details::printPtr(os,
-                          *(params->phCommand));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_command_buffer_update_kernel_launch_exp_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_update_kernel_launch_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommand = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommand)
+        );
 
-    os << ".hCommand = ";
-
-    ur::details::printPtr(os,
-                          *(params->phCommand));
 
-    os << ", ";
-    os << ".pUpdateKernelLaunch = ";
+        
+    
+        os << ", ";
+        os << ".pUpdateKernelLaunch = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppUpdateKernelLaunch)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppUpdateKernelLaunch));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_command_buffer_update_signal_event_exp_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_update_signal_event_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommand = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommand)
+        );
 
-    os << ".hCommand = ";
-
-    ur::details::printPtr(os,
-                          *(params->phCommand));
 
-    os << ", ";
-    os << ".phSignalEvent = ";
+        
+    
+        os << ", ";
+        os << ".phSignalEvent = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphSignalEvent)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphSignalEvent));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_command_buffer_update_wait_events_exp_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_update_wait_events_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommand = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommand)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".numEventsInWaitList = ";
+        
+        os << 
+            *(params->pnumEventsInWaitList)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phEventWaitList = {";
+        for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphEventWaitList))[i]
+            );
 
-    os << ".hCommand = ";
-
-    ur::details::printPtr(os,
-                          *(params->phCommand));
-
-    os << ", ";
-    os << ".numEventsInWaitList = ";
-
-    os << *(params->pnumEventsInWaitList);
-
-    os << ", ";
-    os << ".phEventWaitList = {";
-    for (size_t i = 0; *(params->pphEventWaitList) != NULL && i < *params->pnumEventsInWaitList; ++i) {
-        if (i != 0) {
-            os << ", ";
         }
-
-        ur::details::printPtr(os,
-                              (*(params->pphEventWaitList))[i]);
-    }
-    os << "}";
+        os << "}";
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_command_buffer_get_info_exp_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_get_info_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommandBuffer = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommandBuffer)
+        );
 
-    os << ".hCommandBuffer = ";
-
-    ur::details::printPtr(os,
-                          *(params->phCommandBuffer));
 
-    os << ", ";
-    os << ".propName = ";
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << *(params->ppropName);
 
-    os << ", ";
-    os << ".propSize = ";
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    os << *(params->ppropSize);
 
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".pPropSizeRet = ";
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_command_buffer_command_get_info_exp_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_command_buffer_command_get_info_exp_params_t *params) {
+    
+        
+    
+        os << ".hCommand = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phCommand)
+        );
 
-    os << ".hCommand = ";
-
-    ur::details::printPtr(os,
-                          *(params->phCommand));
 
-    os << ", ";
-    os << ".propName = ";
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << *(params->ppropName);
 
-    os << ", ";
-    os << ".propSize = ";
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    os << *(params->ppropSize);
 
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".pPropSizeRet = ";
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_usm_p2p_enable_peer_access_exp_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_p2p_enable_peer_access_exp_params_t *params) {
+    
+        
+    
+        os << ".commandDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pcommandDevice)
+        );
 
-    os << ".commandDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->pcommandDevice));
 
-    os << ", ";
-    os << ".peerDevice = ";
+        
+    
+        os << ", ";
+        os << ".peerDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppeerDevice)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppeerDevice));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_usm_p2p_disable_peer_access_exp_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_p2p_disable_peer_access_exp_params_t *params) {
+    
+        
+    
+        os << ".commandDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pcommandDevice)
+        );
 
-    os << ".commandDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->pcommandDevice));
 
-    os << ", ";
-    os << ".peerDevice = ";
+        
+    
+        os << ", ";
+        os << ".peerDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppeerDevice)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppeerDevice));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_usm_p2p_peer_access_get_info_exp_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_usm_p2p_peer_access_get_info_exp_params_t *params) {
+    
+        
+    
+        os << ".commandDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pcommandDevice)
+        );
 
-    os << ".commandDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->pcommandDevice));
 
-    os << ", ";
-    os << ".peerDevice = ";
+        
+    
+        os << ", ";
+        os << ".peerDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppeerDevice)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppeerDevice));
 
-    os << ", ";
-    os << ".propName = ";
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << *(params->ppropName);
 
-    os << ", ";
-    os << ".propSize = ";
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    os << *(params->ppropSize);
 
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".pPropSizeRet = ";
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_loader_init_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_loader_init_params_t *params) {
+    
+        
+    
+        os << ".device_flags = ";
+        
+        ur::details::printFlag<ur_device_init_flag_t>(os, 
+            *(params->pdevice_flags)
+        );
 
-    os << ".device_flags = ";
-
-    ur::details::printFlag<ur_device_init_flag_t>(os,
-                                                  *(params->pdevice_flags));
 
-    os << ", ";
-    os << ".hLoaderConfig = ";
+        
+    
+        os << ", ";
+        os << ".hLoaderConfig = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phLoaderConfig)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phLoaderConfig));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_loader_tear_down_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_loader_tear_down_params_t *params) {
-
+    
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_virtual_mem_granularity_get_info_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_virtual_mem_granularity_get_info_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
 
-    os << ", ";
-    os << ".hDevice = ";
+        
+    
+        os << ", ";
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phDevice));
 
-    os << ", ";
-    os << ".propName = ";
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << *(params->ppropName);
 
-    os << ", ";
-    os << ".propSize = ";
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    os << *(params->ppropSize);
 
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".pPropSizeRet = ";
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_virtual_mem_reserve_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_virtual_mem_reserve_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
 
-    os << ", ";
-    os << ".pStart = ";
+        
+    
+        os << ", ";
+        os << ".pStart = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppStart)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppStart));
 
-    os << ", ";
-    os << ".size = ";
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
 
-    os << *(params->psize);
 
-    os << ", ";
-    os << ".ppStart = ";
+        
+    
+        os << ", ";
+        os << ".ppStart = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pppStart)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pppStart));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_virtual_mem_free_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_virtual_mem_free_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
 
-    os << ", ";
-    os << ".pStart = ";
+        
+    
+        os << ", ";
+        os << ".pStart = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppStart)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppStart));
 
-    os << ", ";
-    os << ".size = ";
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
 
-    os << *(params->psize);
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_virtual_mem_map_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_virtual_mem_map_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
 
-    os << ", ";
-    os << ".pStart = ";
+        
+    
+        os << ", ";
+        os << ".pStart = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppStart)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppStart));
 
-    os << ", ";
-    os << ".size = ";
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
 
-    os << *(params->psize);
 
-    os << ", ";
-    os << ".hPhysicalMem = ";
+        
+    
+        os << ", ";
+        os << ".hPhysicalMem = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phPhysicalMem)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phPhysicalMem));
 
-    os << ", ";
-    os << ".offset = ";
+        
+    
+        os << ", ";
+        os << ".offset = ";
+        
+        os << 
+            *(params->poffset)
+        ;
 
-    os << *(params->poffset);
 
-    os << ", ";
-    os << ".flags = ";
+        
+    
+        os << ", ";
+        os << ".flags = ";
+        
+        ur::details::printFlag<ur_virtual_mem_access_flag_t>(os, 
+            *(params->pflags)
+        );
 
-    ur::details::printFlag<ur_virtual_mem_access_flag_t>(os,
-                                                         *(params->pflags));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_virtual_mem_unmap_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_virtual_mem_unmap_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
 
-    os << ", ";
-    os << ".pStart = ";
+        
+    
+        os << ", ";
+        os << ".pStart = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppStart)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppStart));
 
-    os << ", ";
-    os << ".size = ";
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
 
-    os << *(params->psize);
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_virtual_mem_set_access_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_virtual_mem_set_access_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
 
-    os << ", ";
-    os << ".pStart = ";
+        
+    
+        os << ", ";
+        os << ".pStart = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppStart)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppStart));
 
-    os << ", ";
-    os << ".size = ";
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
 
-    os << *(params->psize);
 
-    os << ", ";
-    os << ".flags = ";
+        
+    
+        os << ", ";
+        os << ".flags = ";
+        
+        ur::details::printFlag<ur_virtual_mem_access_flag_t>(os, 
+            *(params->pflags)
+        );
 
-    ur::details::printFlag<ur_virtual_mem_access_flag_t>(os,
-                                                         *(params->pflags));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_virtual_mem_get_info_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_virtual_mem_get_info_params_t *params) {
+    
+        
+    
+        os << ".hContext = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phContext)
+        );
 
-    os << ".hContext = ";
-
-    ur::details::printPtr(os,
-                          *(params->phContext));
 
-    os << ", ";
-    os << ".pStart = ";
+        
+    
+        os << ", ";
+        os << ".pStart = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppStart)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppStart));
 
-    os << ", ";
-    os << ".size = ";
+        
+    
+        os << ", ";
+        os << ".size = ";
+        
+        os << 
+            *(params->psize)
+        ;
 
-    os << *(params->psize);
 
-    os << ", ";
-    os << ".propName = ";
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << *(params->ppropName);
 
-    os << ", ";
-    os << ".propSize = ";
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    os << *(params->ppropSize);
 
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".pPropSizeRet = ";
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_device_get_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_device_get_params_t *params) {
+    
+        
+    
+        os << ".hPlatform = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phPlatform)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".DeviceType = ";
+        
+        os << 
+            *(params->pDeviceType)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".NumEntries = ";
+        
+        os << 
+            *(params->pNumEntries)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phDevices = {";
+        for (size_t i = 0; *(params->pphDevices) != NULL && i < *params->pNumEntries; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphDevices))[i]
+            );
 
-    os << ".hPlatform = ";
-
-    ur::details::printPtr(os,
-                          *(params->phPlatform));
-
-    os << ", ";
-    os << ".DeviceType = ";
-
-    os << *(params->pDeviceType);
-
-    os << ", ";
-    os << ".NumEntries = ";
-
-    os << *(params->pNumEntries);
-
-    os << ", ";
-    os << ".phDevices = {";
-    for (size_t i = 0; *(params->pphDevices) != NULL && i < *params->pNumEntries; ++i) {
-        if (i != 0) {
-            os << ", ";
         }
+        os << "}";
 
-        ur::details::printPtr(os,
-                              (*(params->pphDevices))[i]);
-    }
-    os << "}";
-
-    os << ", ";
-    os << ".pNumDevices = ";
+        
+    
+        os << ", ";
+        os << ".pNumDevices = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppNumDevices)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppNumDevices));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_device_get_selected_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_device_get_selected_params_t *params) {
+    
+        
+    
+        os << ".hPlatform = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phPlatform)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".DeviceType = ";
+        
+        os << 
+            *(params->pDeviceType)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".NumEntries = ";
+        
+        os << 
+            *(params->pNumEntries)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phDevices = {";
+        for (size_t i = 0; *(params->pphDevices) != NULL && i < *params->pNumEntries; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphDevices))[i]
+            );
 
-    os << ".hPlatform = ";
-
-    ur::details::printPtr(os,
-                          *(params->phPlatform));
-
-    os << ", ";
-    os << ".DeviceType = ";
-
-    os << *(params->pDeviceType);
-
-    os << ", ";
-    os << ".NumEntries = ";
-
-    os << *(params->pNumEntries);
-
-    os << ", ";
-    os << ".phDevices = {";
-    for (size_t i = 0; *(params->pphDevices) != NULL && i < *params->pNumEntries; ++i) {
-        if (i != 0) {
-            os << ", ";
         }
+        os << "}";
 
-        ur::details::printPtr(os,
-                              (*(params->pphDevices))[i]);
-    }
-    os << "}";
-
-    os << ", ";
-    os << ".pNumDevices = ";
+        
+    
+        os << ", ";
+        os << ".pNumDevices = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppNumDevices)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppNumDevices));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_device_get_info_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_device_get_info_params_t *params) {
+    
+        
+    
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << ".hDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->phDevice));
 
-    os << ", ";
-    os << ".propName = ";
+        
+    
+        os << ", ";
+        os << ".propName = ";
+        
+        os << 
+            *(params->ppropName)
+        ;
 
-    os << *(params->ppropName);
 
-    os << ", ";
-    os << ".propSize = ";
+        
+    
+        os << ", ";
+        os << ".propSize = ";
+        
+        os << 
+            *(params->ppropSize)
+        ;
 
-    os << *(params->ppropSize);
 
-    os << ", ";
-    os << ".pPropValue = ";
-    ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
+        
+    
+        os << ", ";
+        os << ".pPropValue = ";
+        ur::details::printTagged(os, *(params->ppPropValue), *(params->ppropName), *(params->ppropSize));
 
-    os << ", ";
-    os << ".pPropSizeRet = ";
+        
+    
+        os << ", ";
+        os << ".pPropSizeRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppPropSizeRet)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppPropSizeRet));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_device_retain_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_device_retain_params_t *params) {
+    
+        
+    
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << ".hDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->phDevice));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_device_release_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_device_release_params_t *params) {
+    
+        
+    
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << ".hDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->phDevice));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_device_partition_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_device_partition_params_t *params) {
+    
+        
+    
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
+
+
+        
+    
+        os << ", ";
+        os << ".NumDevices = ";
+        
+        os << 
+            *(params->pNumDevices)
+        ;
+
+
+        
+    
+        os << ", ";
+        os << ".phSubDevices = {";
+        for (size_t i = 0; *(params->pphSubDevices) != NULL && i < *params->pNumDevices; ++i) {
+            if (i != 0) {
+                os << ", ";
+            }
+            
+        ur::details::printPtr(os, 
+                (*(params->pphSubDevices))[i]
+            );
 
-    os << ".hDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->phDevice));
-
-    os << ", ";
-    os << ".pProperties = ";
-
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
-
-    os << ", ";
-    os << ".NumDevices = ";
-
-    os << *(params->pNumDevices);
-
-    os << ", ";
-    os << ".phSubDevices = {";
-    for (size_t i = 0; *(params->pphSubDevices) != NULL && i < *params->pNumDevices; ++i) {
-        if (i != 0) {
-            os << ", ";
         }
+        os << "}";
 
-        ur::details::printPtr(os,
-                              (*(params->pphSubDevices))[i]);
-    }
-    os << "}";
-
-    os << ", ";
-    os << ".pNumDevicesRet = ";
+        
+    
+        os << ", ";
+        os << ".pNumDevicesRet = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppNumDevicesRet)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppNumDevicesRet));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_device_select_binary_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_device_select_binary_params_t *params) {
+    
+        
+    
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << ".hDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->phDevice));
 
-    os << ", ";
-    os << ".pBinaries = ";
+        
+    
+        os << ", ";
+        os << ".pBinaries = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppBinaries)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppBinaries));
 
-    os << ", ";
-    os << ".NumBinaries = ";
+        
+    
+        os << ", ";
+        os << ".NumBinaries = ";
+        
+        os << 
+            *(params->pNumBinaries)
+        ;
 
-    os << *(params->pNumBinaries);
 
-    os << ", ";
-    os << ".pSelectedBinary = ";
+        
+    
+        os << ", ";
+        os << ".pSelectedBinary = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppSelectedBinary)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppSelectedBinary));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_device_get_native_handle_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_device_get_native_handle_params_t *params) {
+    
+        
+    
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << ".hDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->phDevice));
 
-    os << ", ";
-    os << ".phNativeDevice = ";
+        
+    
+        os << ", ";
+        os << ".phNativeDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphNativeDevice)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphNativeDevice));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_device_create_with_native_handle_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_device_create_with_native_handle_params_t *params) {
+    
+        
+    
+        os << ".hNativeDevice = ";
+        
+        ur::details::printPtr(os, reinterpret_cast<void*>(
+            *(params->phNativeDevice)
+        ));
 
-    os << ".hNativeDevice = ";
-
-    ur::details::printPtr(os, reinterpret_cast<void *>(
-                                  *(params->phNativeDevice)));
 
-    os << ", ";
-    os << ".hAdapter = ";
+        
+    
+        os << ", ";
+        os << ".hAdapter = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phAdapter)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->phAdapter));
 
-    os << ", ";
-    os << ".pProperties = ";
+        
+    
+        os << ", ";
+        os << ".pProperties = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppProperties)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppProperties));
 
-    os << ", ";
-    os << ".phDevice = ";
+        
+    
+        os << ", ";
+        os << ".phDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->pphDevice)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->pphDevice));
 
     return os;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print operator for the ur_device_get_global_timestamps_params_t type
 /// @returns
 ///     std::ostream &
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_device_get_global_timestamps_params_t *params) {
+    
+        
+    
+        os << ".hDevice = ";
+        
+        ur::details::printPtr(os, 
+            *(params->phDevice)
+        );
 
-    os << ".hDevice = ";
-
-    ur::details::printPtr(os,
-                          *(params->phDevice));
 
-    os << ", ";
-    os << ".pDeviceTimestamp = ";
+        
+    
+        os << ", ";
+        os << ".pDeviceTimestamp = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppDeviceTimestamp)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppDeviceTimestamp));
 
-    os << ", ";
-    os << ".pHostTimestamp = ";
+        
+    
+        os << ", ";
+        os << ".pHostTimestamp = ";
+        
+        ur::details::printPtr(os, 
+            *(params->ppHostTimestamp)
+        );
 
-    ur::details::printPtr(os,
-                          *(params->ppHostTimestamp));
 
     return os;
 }
 
+
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const ur_bool_t value) {
     os << (value ? "true" : "false");
     return os;
@@ -17997,8 +24496,7 @@ inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const ur_bool
 namespace ur::details {
 ///////////////////////////////////////////////////////////////////////////////
 // @brief Print pointer value
-template <typename T>
-inline ur_result_t printPtr(std::ostream &os, const T *ptr) {
+template <typename T> inline ur_result_t printPtr(std::ostream &os, const T *ptr) {
     if (ptr == nullptr) {
         os << "nullptr";
     } else if constexpr (std::is_pointer_v<T>) {
@@ -18007,7 +24505,7 @@ inline ur_result_t printPtr(std::ostream &os, const T *ptr) {
         os << ")";
     } else if constexpr (std::is_void_v<T> || is_handle_v<T *>) {
         os << (const void *)ptr;
-    } else if constexpr (std::is_same_v<std::remove_cv_t<T>, char>) {
+    } else if constexpr (std::is_same_v<std::remove_cv_t< T >, char>) {
         os << (const void *)(ptr) << " (";
         os << ptr;
         os << ")";
@@ -18034,606 +24532,605 @@ inline ur_result_t UR_APICALL printFunctionParams(std::ostream &os, ur_function_
         return UR_RESULT_ERROR_INVALID_NULL_POINTER;
     }
 
-    switch (function) {
-    case UR_FUNCTION_LOADER_CONFIG_CREATE: {
-        os << (const struct ur_loader_config_create_params_t *)params;
-    } break;
-    case UR_FUNCTION_LOADER_CONFIG_RETAIN: {
-        os << (const struct ur_loader_config_retain_params_t *)params;
-    } break;
-    case UR_FUNCTION_LOADER_CONFIG_RELEASE: {
-        os << (const struct ur_loader_config_release_params_t *)params;
-    } break;
-    case UR_FUNCTION_LOADER_CONFIG_GET_INFO: {
-        os << (const struct ur_loader_config_get_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_LOADER_CONFIG_ENABLE_LAYER: {
-        os << (const struct ur_loader_config_enable_layer_params_t *)params;
-    } break;
-    case UR_FUNCTION_LOADER_CONFIG_SET_CODE_LOCATION_CALLBACK: {
-        os << (const struct ur_loader_config_set_code_location_callback_params_t *)params;
-    } break;
-    case UR_FUNCTION_LOADER_CONFIG_SET_MOCKING_ENABLED: {
-        os << (const struct ur_loader_config_set_mocking_enabled_params_t *)params;
-    } break;
-    case UR_FUNCTION_PLATFORM_GET: {
-        os << (const struct ur_platform_get_params_t *)params;
-    } break;
-    case UR_FUNCTION_PLATFORM_GET_INFO: {
-        os << (const struct ur_platform_get_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_PLATFORM_GET_NATIVE_HANDLE: {
-        os << (const struct ur_platform_get_native_handle_params_t *)params;
-    } break;
-    case UR_FUNCTION_PLATFORM_CREATE_WITH_NATIVE_HANDLE: {
-        os << (const struct ur_platform_create_with_native_handle_params_t *)params;
-    } break;
-    case UR_FUNCTION_PLATFORM_GET_API_VERSION: {
-        os << (const struct ur_platform_get_api_version_params_t *)params;
-    } break;
-    case UR_FUNCTION_PLATFORM_GET_BACKEND_OPTION: {
-        os << (const struct ur_platform_get_backend_option_params_t *)params;
-    } break;
-    case UR_FUNCTION_CONTEXT_CREATE: {
-        os << (const struct ur_context_create_params_t *)params;
-    } break;
-    case UR_FUNCTION_CONTEXT_RETAIN: {
-        os << (const struct ur_context_retain_params_t *)params;
-    } break;
-    case UR_FUNCTION_CONTEXT_RELEASE: {
-        os << (const struct ur_context_release_params_t *)params;
-    } break;
-    case UR_FUNCTION_CONTEXT_GET_INFO: {
-        os << (const struct ur_context_get_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_CONTEXT_GET_NATIVE_HANDLE: {
-        os << (const struct ur_context_get_native_handle_params_t *)params;
-    } break;
-    case UR_FUNCTION_CONTEXT_CREATE_WITH_NATIVE_HANDLE: {
-        os << (const struct ur_context_create_with_native_handle_params_t *)params;
-    } break;
-    case UR_FUNCTION_CONTEXT_SET_EXTENDED_DELETER: {
-        os << (const struct ur_context_set_extended_deleter_params_t *)params;
-    } break;
-    case UR_FUNCTION_EVENT_GET_INFO: {
-        os << (const struct ur_event_get_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_EVENT_GET_PROFILING_INFO: {
-        os << (const struct ur_event_get_profiling_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_EVENT_WAIT: {
-        os << (const struct ur_event_wait_params_t *)params;
-    } break;
-    case UR_FUNCTION_EVENT_RETAIN: {
-        os << (const struct ur_event_retain_params_t *)params;
-    } break;
-    case UR_FUNCTION_EVENT_RELEASE: {
-        os << (const struct ur_event_release_params_t *)params;
-    } break;
-    case UR_FUNCTION_EVENT_GET_NATIVE_HANDLE: {
-        os << (const struct ur_event_get_native_handle_params_t *)params;
-    } break;
-    case UR_FUNCTION_EVENT_CREATE_WITH_NATIVE_HANDLE: {
-        os << (const struct ur_event_create_with_native_handle_params_t *)params;
-    } break;
-    case UR_FUNCTION_EVENT_SET_CALLBACK: {
-        os << (const struct ur_event_set_callback_params_t *)params;
-    } break;
-    case UR_FUNCTION_PROGRAM_CREATE_WITH_IL: {
-        os << (const struct ur_program_create_with_il_params_t *)params;
-    } break;
-    case UR_FUNCTION_PROGRAM_CREATE_WITH_BINARY: {
-        os << (const struct ur_program_create_with_binary_params_t *)params;
-    } break;
-    case UR_FUNCTION_PROGRAM_BUILD: {
-        os << (const struct ur_program_build_params_t *)params;
-    } break;
-    case UR_FUNCTION_PROGRAM_BUILD_EXP: {
-        os << (const struct ur_program_build_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_PROGRAM_COMPILE: {
-        os << (const struct ur_program_compile_params_t *)params;
-    } break;
-    case UR_FUNCTION_PROGRAM_COMPILE_EXP: {
-        os << (const struct ur_program_compile_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_PROGRAM_LINK: {
-        os << (const struct ur_program_link_params_t *)params;
-    } break;
-    case UR_FUNCTION_PROGRAM_LINK_EXP: {
-        os << (const struct ur_program_link_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_PROGRAM_RETAIN: {
-        os << (const struct ur_program_retain_params_t *)params;
-    } break;
-    case UR_FUNCTION_PROGRAM_RELEASE: {
-        os << (const struct ur_program_release_params_t *)params;
-    } break;
-    case UR_FUNCTION_PROGRAM_GET_FUNCTION_POINTER: {
-        os << (const struct ur_program_get_function_pointer_params_t *)params;
-    } break;
-    case UR_FUNCTION_PROGRAM_GET_GLOBAL_VARIABLE_POINTER: {
-        os << (const struct ur_program_get_global_variable_pointer_params_t *)params;
-    } break;
-    case UR_FUNCTION_PROGRAM_GET_INFO: {
-        os << (const struct ur_program_get_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_PROGRAM_GET_BUILD_INFO: {
-        os << (const struct ur_program_get_build_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_PROGRAM_SET_SPECIALIZATION_CONSTANTS: {
-        os << (const struct ur_program_set_specialization_constants_params_t *)params;
-    } break;
-    case UR_FUNCTION_PROGRAM_GET_NATIVE_HANDLE: {
-        os << (const struct ur_program_get_native_handle_params_t *)params;
-    } break;
-    case UR_FUNCTION_PROGRAM_CREATE_WITH_NATIVE_HANDLE: {
-        os << (const struct ur_program_create_with_native_handle_params_t *)params;
-    } break;
-    case UR_FUNCTION_KERNEL_CREATE: {
-        os << (const struct ur_kernel_create_params_t *)params;
-    } break;
-    case UR_FUNCTION_KERNEL_GET_INFO: {
-        os << (const struct ur_kernel_get_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_KERNEL_GET_GROUP_INFO: {
-        os << (const struct ur_kernel_get_group_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_KERNEL_GET_SUB_GROUP_INFO: {
-        os << (const struct ur_kernel_get_sub_group_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_KERNEL_RETAIN: {
-        os << (const struct ur_kernel_retain_params_t *)params;
-    } break;
-    case UR_FUNCTION_KERNEL_RELEASE: {
-        os << (const struct ur_kernel_release_params_t *)params;
-    } break;
-    case UR_FUNCTION_KERNEL_GET_NATIVE_HANDLE: {
-        os << (const struct ur_kernel_get_native_handle_params_t *)params;
-    } break;
-    case UR_FUNCTION_KERNEL_CREATE_WITH_NATIVE_HANDLE: {
-        os << (const struct ur_kernel_create_with_native_handle_params_t *)params;
-    } break;
-    case UR_FUNCTION_KERNEL_GET_SUGGESTED_LOCAL_WORK_SIZE: {
-        os << (const struct ur_kernel_get_suggested_local_work_size_params_t *)params;
-    } break;
-    case UR_FUNCTION_KERNEL_SET_ARG_VALUE: {
-        os << (const struct ur_kernel_set_arg_value_params_t *)params;
-    } break;
-    case UR_FUNCTION_KERNEL_SET_ARG_LOCAL: {
-        os << (const struct ur_kernel_set_arg_local_params_t *)params;
-    } break;
-    case UR_FUNCTION_KERNEL_SET_ARG_POINTER: {
-        os << (const struct ur_kernel_set_arg_pointer_params_t *)params;
-    } break;
-    case UR_FUNCTION_KERNEL_SET_EXEC_INFO: {
-        os << (const struct ur_kernel_set_exec_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_KERNEL_SET_ARG_SAMPLER: {
-        os << (const struct ur_kernel_set_arg_sampler_params_t *)params;
-    } break;
-    case UR_FUNCTION_KERNEL_SET_ARG_MEM_OBJ: {
-        os << (const struct ur_kernel_set_arg_mem_obj_params_t *)params;
-    } break;
-    case UR_FUNCTION_KERNEL_SET_SPECIALIZATION_CONSTANTS: {
-        os << (const struct ur_kernel_set_specialization_constants_params_t *)params;
-    } break;
-    case UR_FUNCTION_KERNEL_SUGGEST_MAX_COOPERATIVE_GROUP_COUNT_EXP: {
-        os << (const struct ur_kernel_suggest_max_cooperative_group_count_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_QUEUE_GET_INFO: {
-        os << (const struct ur_queue_get_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_QUEUE_CREATE: {
-        os << (const struct ur_queue_create_params_t *)params;
-    } break;
-    case UR_FUNCTION_QUEUE_RETAIN: {
-        os << (const struct ur_queue_retain_params_t *)params;
-    } break;
-    case UR_FUNCTION_QUEUE_RELEASE: {
-        os << (const struct ur_queue_release_params_t *)params;
-    } break;
-    case UR_FUNCTION_QUEUE_GET_NATIVE_HANDLE: {
-        os << (const struct ur_queue_get_native_handle_params_t *)params;
-    } break;
-    case UR_FUNCTION_QUEUE_CREATE_WITH_NATIVE_HANDLE: {
-        os << (const struct ur_queue_create_with_native_handle_params_t *)params;
-    } break;
-    case UR_FUNCTION_QUEUE_FINISH: {
-        os << (const struct ur_queue_finish_params_t *)params;
-    } break;
-    case UR_FUNCTION_QUEUE_FLUSH: {
-        os << (const struct ur_queue_flush_params_t *)params;
-    } break;
-    case UR_FUNCTION_SAMPLER_CREATE: {
-        os << (const struct ur_sampler_create_params_t *)params;
-    } break;
-    case UR_FUNCTION_SAMPLER_RETAIN: {
-        os << (const struct ur_sampler_retain_params_t *)params;
-    } break;
-    case UR_FUNCTION_SAMPLER_RELEASE: {
-        os << (const struct ur_sampler_release_params_t *)params;
-    } break;
-    case UR_FUNCTION_SAMPLER_GET_INFO: {
-        os << (const struct ur_sampler_get_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_SAMPLER_GET_NATIVE_HANDLE: {
-        os << (const struct ur_sampler_get_native_handle_params_t *)params;
-    } break;
-    case UR_FUNCTION_SAMPLER_CREATE_WITH_NATIVE_HANDLE: {
-        os << (const struct ur_sampler_create_with_native_handle_params_t *)params;
-    } break;
-    case UR_FUNCTION_MEM_IMAGE_CREATE: {
-        os << (const struct ur_mem_image_create_params_t *)params;
-    } break;
-    case UR_FUNCTION_MEM_BUFFER_CREATE: {
-        os << (const struct ur_mem_buffer_create_params_t *)params;
-    } break;
-    case UR_FUNCTION_MEM_RETAIN: {
-        os << (const struct ur_mem_retain_params_t *)params;
-    } break;
-    case UR_FUNCTION_MEM_RELEASE: {
-        os << (const struct ur_mem_release_params_t *)params;
-    } break;
-    case UR_FUNCTION_MEM_BUFFER_PARTITION: {
-        os << (const struct ur_mem_buffer_partition_params_t *)params;
-    } break;
-    case UR_FUNCTION_MEM_GET_NATIVE_HANDLE: {
-        os << (const struct ur_mem_get_native_handle_params_t *)params;
-    } break;
-    case UR_FUNCTION_MEM_BUFFER_CREATE_WITH_NATIVE_HANDLE: {
-        os << (const struct ur_mem_buffer_create_with_native_handle_params_t *)params;
-    } break;
-    case UR_FUNCTION_MEM_IMAGE_CREATE_WITH_NATIVE_HANDLE: {
-        os << (const struct ur_mem_image_create_with_native_handle_params_t *)params;
-    } break;
-    case UR_FUNCTION_MEM_GET_INFO: {
-        os << (const struct ur_mem_get_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_MEM_IMAGE_GET_INFO: {
-        os << (const struct ur_mem_image_get_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_PHYSICAL_MEM_CREATE: {
-        os << (const struct ur_physical_mem_create_params_t *)params;
-    } break;
-    case UR_FUNCTION_PHYSICAL_MEM_RETAIN: {
-        os << (const struct ur_physical_mem_retain_params_t *)params;
-    } break;
-    case UR_FUNCTION_PHYSICAL_MEM_RELEASE: {
-        os << (const struct ur_physical_mem_release_params_t *)params;
-    } break;
-    case UR_FUNCTION_ADAPTER_GET: {
-        os << (const struct ur_adapter_get_params_t *)params;
-    } break;
-    case UR_FUNCTION_ADAPTER_RELEASE: {
-        os << (const struct ur_adapter_release_params_t *)params;
-    } break;
-    case UR_FUNCTION_ADAPTER_RETAIN: {
-        os << (const struct ur_adapter_retain_params_t *)params;
-    } break;
-    case UR_FUNCTION_ADAPTER_GET_LAST_ERROR: {
-        os << (const struct ur_adapter_get_last_error_params_t *)params;
-    } break;
-    case UR_FUNCTION_ADAPTER_GET_INFO: {
-        os << (const struct ur_adapter_get_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH: {
-        os << (const struct ur_enqueue_kernel_launch_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_EVENTS_WAIT: {
-        os << (const struct ur_enqueue_events_wait_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_EVENTS_WAIT_WITH_BARRIER: {
-        os << (const struct ur_enqueue_events_wait_with_barrier_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ: {
-        os << (const struct ur_enqueue_mem_buffer_read_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE: {
-        os << (const struct ur_enqueue_mem_buffer_write_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ_RECT: {
-        os << (const struct ur_enqueue_mem_buffer_read_rect_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE_RECT: {
-        os << (const struct ur_enqueue_mem_buffer_write_rect_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY: {
-        os << (const struct ur_enqueue_mem_buffer_copy_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY_RECT: {
-        os << (const struct ur_enqueue_mem_buffer_copy_rect_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_MEM_BUFFER_FILL: {
-        os << (const struct ur_enqueue_mem_buffer_fill_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_MEM_IMAGE_READ: {
-        os << (const struct ur_enqueue_mem_image_read_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_MEM_IMAGE_WRITE: {
-        os << (const struct ur_enqueue_mem_image_write_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_MEM_IMAGE_COPY: {
-        os << (const struct ur_enqueue_mem_image_copy_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_MEM_BUFFER_MAP: {
-        os << (const struct ur_enqueue_mem_buffer_map_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_MEM_UNMAP: {
-        os << (const struct ur_enqueue_mem_unmap_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_USM_FILL: {
-        os << (const struct ur_enqueue_usm_fill_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_USM_MEMCPY: {
-        os << (const struct ur_enqueue_usm_memcpy_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_USM_PREFETCH: {
-        os << (const struct ur_enqueue_usm_prefetch_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_USM_ADVISE: {
-        os << (const struct ur_enqueue_usm_advise_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_USM_FILL_2D: {
-        os << (const struct ur_enqueue_usm_fill_2d_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_USM_MEMCPY_2D: {
-        os << (const struct ur_enqueue_usm_memcpy_2d_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_WRITE: {
-        os << (const struct ur_enqueue_device_global_variable_write_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_READ: {
-        os << (const struct ur_enqueue_device_global_variable_read_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_READ_HOST_PIPE: {
-        os << (const struct ur_enqueue_read_host_pipe_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_WRITE_HOST_PIPE: {
-        os << (const struct ur_enqueue_write_host_pipe_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH_CUSTOM_EXP: {
-        os << (const struct ur_enqueue_kernel_launch_custom_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_COOPERATIVE_KERNEL_LAUNCH_EXP: {
-        os << (const struct ur_enqueue_cooperative_kernel_launch_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_TIMESTAMP_RECORDING_EXP: {
-        os << (const struct ur_enqueue_timestamp_recording_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_ENQUEUE_NATIVE_COMMAND_EXP: {
-        os << (const struct ur_enqueue_native_command_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_HANDLE_DESTROY_EXP: {
-        os << (const struct ur_bindless_images_unsampled_image_handle_destroy_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_HANDLE_DESTROY_EXP: {
-        os << (const struct ur_bindless_images_sampled_image_handle_destroy_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_BINDLESS_IMAGES_IMAGE_ALLOCATE_EXP: {
-        os << (const struct ur_bindless_images_image_allocate_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_BINDLESS_IMAGES_IMAGE_FREE_EXP: {
-        os << (const struct ur_bindless_images_image_free_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_CREATE_EXP: {
-        os << (const struct ur_bindless_images_unsampled_image_create_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_CREATE_EXP: {
-        os << (const struct ur_bindless_images_sampled_image_create_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_BINDLESS_IMAGES_IMAGE_COPY_EXP: {
-        os << (const struct ur_bindless_images_image_copy_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_BINDLESS_IMAGES_IMAGE_GET_INFO_EXP: {
-        os << (const struct ur_bindless_images_image_get_info_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_GET_LEVEL_EXP: {
-        os << (const struct ur_bindless_images_mipmap_get_level_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_FREE_EXP: {
-        os << (const struct ur_bindless_images_mipmap_free_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_MEMORY_EXP: {
-        os << (const struct ur_bindless_images_import_external_memory_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_ARRAY_EXP: {
-        os << (const struct ur_bindless_images_map_external_array_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_LINEAR_MEMORY_EXP: {
-        os << (const struct ur_bindless_images_map_external_linear_memory_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_MEMORY_EXP: {
-        os << (const struct ur_bindless_images_release_external_memory_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_SEMAPHORE_EXP: {
-        os << (const struct ur_bindless_images_import_external_semaphore_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_SEMAPHORE_EXP: {
-        os << (const struct ur_bindless_images_release_external_semaphore_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_BINDLESS_IMAGES_WAIT_EXTERNAL_SEMAPHORE_EXP: {
-        os << (const struct ur_bindless_images_wait_external_semaphore_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_BINDLESS_IMAGES_SIGNAL_EXTERNAL_SEMAPHORE_EXP: {
-        os << (const struct ur_bindless_images_signal_external_semaphore_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_USM_HOST_ALLOC: {
-        os << (const struct ur_usm_host_alloc_params_t *)params;
-    } break;
-    case UR_FUNCTION_USM_DEVICE_ALLOC: {
-        os << (const struct ur_usm_device_alloc_params_t *)params;
-    } break;
-    case UR_FUNCTION_USM_SHARED_ALLOC: {
-        os << (const struct ur_usm_shared_alloc_params_t *)params;
-    } break;
-    case UR_FUNCTION_USM_FREE: {
-        os << (const struct ur_usm_free_params_t *)params;
-    } break;
-    case UR_FUNCTION_USM_GET_MEM_ALLOC_INFO: {
-        os << (const struct ur_usm_get_mem_alloc_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_USM_POOL_CREATE: {
-        os << (const struct ur_usm_pool_create_params_t *)params;
-    } break;
-    case UR_FUNCTION_USM_POOL_RETAIN: {
-        os << (const struct ur_usm_pool_retain_params_t *)params;
-    } break;
-    case UR_FUNCTION_USM_POOL_RELEASE: {
-        os << (const struct ur_usm_pool_release_params_t *)params;
-    } break;
-    case UR_FUNCTION_USM_POOL_GET_INFO: {
-        os << (const struct ur_usm_pool_get_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_USM_PITCHED_ALLOC_EXP: {
-        os << (const struct ur_usm_pitched_alloc_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_USM_IMPORT_EXP: {
-        os << (const struct ur_usm_import_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_USM_RELEASE_EXP: {
-        os << (const struct ur_usm_release_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_CREATE_EXP: {
-        os << (const struct ur_command_buffer_create_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_RETAIN_EXP: {
-        os << (const struct ur_command_buffer_retain_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_RELEASE_EXP: {
-        os << (const struct ur_command_buffer_release_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_FINALIZE_EXP: {
-        os << (const struct ur_command_buffer_finalize_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_KERNEL_LAUNCH_EXP: {
-        os << (const struct ur_command_buffer_append_kernel_launch_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_MEMCPY_EXP: {
-        os << (const struct ur_command_buffer_append_usm_memcpy_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_FILL_EXP: {
-        os << (const struct ur_command_buffer_append_usm_fill_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_EXP: {
-        os << (const struct ur_command_buffer_append_mem_buffer_copy_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_EXP: {
-        os << (const struct ur_command_buffer_append_mem_buffer_write_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_EXP: {
-        os << (const struct ur_command_buffer_append_mem_buffer_read_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_RECT_EXP: {
-        os << (const struct ur_command_buffer_append_mem_buffer_copy_rect_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_RECT_EXP: {
-        os << (const struct ur_command_buffer_append_mem_buffer_write_rect_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_RECT_EXP: {
-        os << (const struct ur_command_buffer_append_mem_buffer_read_rect_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_FILL_EXP: {
-        os << (const struct ur_command_buffer_append_mem_buffer_fill_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_PREFETCH_EXP: {
-        os << (const struct ur_command_buffer_append_usm_prefetch_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_ADVISE_EXP: {
-        os << (const struct ur_command_buffer_append_usm_advise_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_ENQUEUE_EXP: {
-        os << (const struct ur_command_buffer_enqueue_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_RETAIN_COMMAND_EXP: {
-        os << (const struct ur_command_buffer_retain_command_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_RELEASE_COMMAND_EXP: {
-        os << (const struct ur_command_buffer_release_command_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_UPDATE_KERNEL_LAUNCH_EXP: {
-        os << (const struct ur_command_buffer_update_kernel_launch_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_UPDATE_SIGNAL_EVENT_EXP: {
-        os << (const struct ur_command_buffer_update_signal_event_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_UPDATE_WAIT_EVENTS_EXP: {
-        os << (const struct ur_command_buffer_update_wait_events_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_GET_INFO_EXP: {
-        os << (const struct ur_command_buffer_get_info_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_COMMAND_BUFFER_COMMAND_GET_INFO_EXP: {
-        os << (const struct ur_command_buffer_command_get_info_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_USM_P2P_ENABLE_PEER_ACCESS_EXP: {
-        os << (const struct ur_usm_p2p_enable_peer_access_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_USM_P2P_DISABLE_PEER_ACCESS_EXP: {
-        os << (const struct ur_usm_p2p_disable_peer_access_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_USM_P2P_PEER_ACCESS_GET_INFO_EXP: {
-        os << (const struct ur_usm_p2p_peer_access_get_info_exp_params_t *)params;
-    } break;
-    case UR_FUNCTION_LOADER_INIT: {
-        os << (const struct ur_loader_init_params_t *)params;
-    } break;
-    case UR_FUNCTION_LOADER_TEAR_DOWN: {
-        os << (const struct ur_loader_tear_down_params_t *)params;
-    } break;
-    case UR_FUNCTION_VIRTUAL_MEM_GRANULARITY_GET_INFO: {
-        os << (const struct ur_virtual_mem_granularity_get_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_VIRTUAL_MEM_RESERVE: {
-        os << (const struct ur_virtual_mem_reserve_params_t *)params;
-    } break;
-    case UR_FUNCTION_VIRTUAL_MEM_FREE: {
-        os << (const struct ur_virtual_mem_free_params_t *)params;
-    } break;
-    case UR_FUNCTION_VIRTUAL_MEM_MAP: {
-        os << (const struct ur_virtual_mem_map_params_t *)params;
-    } break;
-    case UR_FUNCTION_VIRTUAL_MEM_UNMAP: {
-        os << (const struct ur_virtual_mem_unmap_params_t *)params;
-    } break;
-    case UR_FUNCTION_VIRTUAL_MEM_SET_ACCESS: {
-        os << (const struct ur_virtual_mem_set_access_params_t *)params;
-    } break;
-    case UR_FUNCTION_VIRTUAL_MEM_GET_INFO: {
-        os << (const struct ur_virtual_mem_get_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_DEVICE_GET: {
-        os << (const struct ur_device_get_params_t *)params;
-    } break;
-    case UR_FUNCTION_DEVICE_GET_SELECTED: {
-        os << (const struct ur_device_get_selected_params_t *)params;
-    } break;
-    case UR_FUNCTION_DEVICE_GET_INFO: {
-        os << (const struct ur_device_get_info_params_t *)params;
-    } break;
-    case UR_FUNCTION_DEVICE_RETAIN: {
-        os << (const struct ur_device_retain_params_t *)params;
-    } break;
-    case UR_FUNCTION_DEVICE_RELEASE: {
-        os << (const struct ur_device_release_params_t *)params;
-    } break;
-    case UR_FUNCTION_DEVICE_PARTITION: {
-        os << (const struct ur_device_partition_params_t *)params;
-    } break;
-    case UR_FUNCTION_DEVICE_SELECT_BINARY: {
-        os << (const struct ur_device_select_binary_params_t *)params;
-    } break;
-    case UR_FUNCTION_DEVICE_GET_NATIVE_HANDLE: {
-        os << (const struct ur_device_get_native_handle_params_t *)params;
-    } break;
-    case UR_FUNCTION_DEVICE_CREATE_WITH_NATIVE_HANDLE: {
-        os << (const struct ur_device_create_with_native_handle_params_t *)params;
-    } break;
-    case UR_FUNCTION_DEVICE_GET_GLOBAL_TIMESTAMPS: {
-        os << (const struct ur_device_get_global_timestamps_params_t *)params;
-    } break;
-    default:
-        return UR_RESULT_ERROR_INVALID_ENUMERATION;
+    switch(function) {
+        case UR_FUNCTION_LOADER_CONFIG_CREATE: {
+            os << (const struct ur_loader_config_create_params_t *)params;
+        } break;
+        case UR_FUNCTION_LOADER_CONFIG_RETAIN: {
+            os << (const struct ur_loader_config_retain_params_t *)params;
+        } break;
+        case UR_FUNCTION_LOADER_CONFIG_RELEASE: {
+            os << (const struct ur_loader_config_release_params_t *)params;
+        } break;
+        case UR_FUNCTION_LOADER_CONFIG_GET_INFO: {
+            os << (const struct ur_loader_config_get_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_LOADER_CONFIG_ENABLE_LAYER: {
+            os << (const struct ur_loader_config_enable_layer_params_t *)params;
+        } break;
+        case UR_FUNCTION_LOADER_CONFIG_SET_CODE_LOCATION_CALLBACK: {
+            os << (const struct ur_loader_config_set_code_location_callback_params_t *)params;
+        } break;
+        case UR_FUNCTION_LOADER_CONFIG_SET_MOCKING_ENABLED: {
+            os << (const struct ur_loader_config_set_mocking_enabled_params_t *)params;
+        } break;
+        case UR_FUNCTION_PLATFORM_GET: {
+            os << (const struct ur_platform_get_params_t *)params;
+        } break;
+        case UR_FUNCTION_PLATFORM_GET_INFO: {
+            os << (const struct ur_platform_get_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_PLATFORM_GET_NATIVE_HANDLE: {
+            os << (const struct ur_platform_get_native_handle_params_t *)params;
+        } break;
+        case UR_FUNCTION_PLATFORM_CREATE_WITH_NATIVE_HANDLE: {
+            os << (const struct ur_platform_create_with_native_handle_params_t *)params;
+        } break;
+        case UR_FUNCTION_PLATFORM_GET_API_VERSION: {
+            os << (const struct ur_platform_get_api_version_params_t *)params;
+        } break;
+        case UR_FUNCTION_PLATFORM_GET_BACKEND_OPTION: {
+            os << (const struct ur_platform_get_backend_option_params_t *)params;
+        } break;
+        case UR_FUNCTION_CONTEXT_CREATE: {
+            os << (const struct ur_context_create_params_t *)params;
+        } break;
+        case UR_FUNCTION_CONTEXT_RETAIN: {
+            os << (const struct ur_context_retain_params_t *)params;
+        } break;
+        case UR_FUNCTION_CONTEXT_RELEASE: {
+            os << (const struct ur_context_release_params_t *)params;
+        } break;
+        case UR_FUNCTION_CONTEXT_GET_INFO: {
+            os << (const struct ur_context_get_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_CONTEXT_GET_NATIVE_HANDLE: {
+            os << (const struct ur_context_get_native_handle_params_t *)params;
+        } break;
+        case UR_FUNCTION_CONTEXT_CREATE_WITH_NATIVE_HANDLE: {
+            os << (const struct ur_context_create_with_native_handle_params_t *)params;
+        } break;
+        case UR_FUNCTION_CONTEXT_SET_EXTENDED_DELETER: {
+            os << (const struct ur_context_set_extended_deleter_params_t *)params;
+        } break;
+        case UR_FUNCTION_EVENT_GET_INFO: {
+            os << (const struct ur_event_get_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_EVENT_GET_PROFILING_INFO: {
+            os << (const struct ur_event_get_profiling_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_EVENT_WAIT: {
+            os << (const struct ur_event_wait_params_t *)params;
+        } break;
+        case UR_FUNCTION_EVENT_RETAIN: {
+            os << (const struct ur_event_retain_params_t *)params;
+        } break;
+        case UR_FUNCTION_EVENT_RELEASE: {
+            os << (const struct ur_event_release_params_t *)params;
+        } break;
+        case UR_FUNCTION_EVENT_GET_NATIVE_HANDLE: {
+            os << (const struct ur_event_get_native_handle_params_t *)params;
+        } break;
+        case UR_FUNCTION_EVENT_CREATE_WITH_NATIVE_HANDLE: {
+            os << (const struct ur_event_create_with_native_handle_params_t *)params;
+        } break;
+        case UR_FUNCTION_EVENT_SET_CALLBACK: {
+            os << (const struct ur_event_set_callback_params_t *)params;
+        } break;
+        case UR_FUNCTION_PROGRAM_CREATE_WITH_IL: {
+            os << (const struct ur_program_create_with_il_params_t *)params;
+        } break;
+        case UR_FUNCTION_PROGRAM_CREATE_WITH_BINARY: {
+            os << (const struct ur_program_create_with_binary_params_t *)params;
+        } break;
+        case UR_FUNCTION_PROGRAM_BUILD: {
+            os << (const struct ur_program_build_params_t *)params;
+        } break;
+        case UR_FUNCTION_PROGRAM_BUILD_EXP: {
+            os << (const struct ur_program_build_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_PROGRAM_COMPILE: {
+            os << (const struct ur_program_compile_params_t *)params;
+        } break;
+        case UR_FUNCTION_PROGRAM_COMPILE_EXP: {
+            os << (const struct ur_program_compile_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_PROGRAM_LINK: {
+            os << (const struct ur_program_link_params_t *)params;
+        } break;
+        case UR_FUNCTION_PROGRAM_LINK_EXP: {
+            os << (const struct ur_program_link_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_PROGRAM_RETAIN: {
+            os << (const struct ur_program_retain_params_t *)params;
+        } break;
+        case UR_FUNCTION_PROGRAM_RELEASE: {
+            os << (const struct ur_program_release_params_t *)params;
+        } break;
+        case UR_FUNCTION_PROGRAM_GET_FUNCTION_POINTER: {
+            os << (const struct ur_program_get_function_pointer_params_t *)params;
+        } break;
+        case UR_FUNCTION_PROGRAM_GET_GLOBAL_VARIABLE_POINTER: {
+            os << (const struct ur_program_get_global_variable_pointer_params_t *)params;
+        } break;
+        case UR_FUNCTION_PROGRAM_GET_INFO: {
+            os << (const struct ur_program_get_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_PROGRAM_GET_BUILD_INFO: {
+            os << (const struct ur_program_get_build_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_PROGRAM_SET_SPECIALIZATION_CONSTANTS: {
+            os << (const struct ur_program_set_specialization_constants_params_t *)params;
+        } break;
+        case UR_FUNCTION_PROGRAM_GET_NATIVE_HANDLE: {
+            os << (const struct ur_program_get_native_handle_params_t *)params;
+        } break;
+        case UR_FUNCTION_PROGRAM_CREATE_WITH_NATIVE_HANDLE: {
+            os << (const struct ur_program_create_with_native_handle_params_t *)params;
+        } break;
+        case UR_FUNCTION_KERNEL_CREATE: {
+            os << (const struct ur_kernel_create_params_t *)params;
+        } break;
+        case UR_FUNCTION_KERNEL_GET_INFO: {
+            os << (const struct ur_kernel_get_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_KERNEL_GET_GROUP_INFO: {
+            os << (const struct ur_kernel_get_group_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_KERNEL_GET_SUB_GROUP_INFO: {
+            os << (const struct ur_kernel_get_sub_group_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_KERNEL_RETAIN: {
+            os << (const struct ur_kernel_retain_params_t *)params;
+        } break;
+        case UR_FUNCTION_KERNEL_RELEASE: {
+            os << (const struct ur_kernel_release_params_t *)params;
+        } break;
+        case UR_FUNCTION_KERNEL_GET_NATIVE_HANDLE: {
+            os << (const struct ur_kernel_get_native_handle_params_t *)params;
+        } break;
+        case UR_FUNCTION_KERNEL_CREATE_WITH_NATIVE_HANDLE: {
+            os << (const struct ur_kernel_create_with_native_handle_params_t *)params;
+        } break;
+        case UR_FUNCTION_KERNEL_GET_SUGGESTED_LOCAL_WORK_SIZE: {
+            os << (const struct ur_kernel_get_suggested_local_work_size_params_t *)params;
+        } break;
+        case UR_FUNCTION_KERNEL_SET_ARG_VALUE: {
+            os << (const struct ur_kernel_set_arg_value_params_t *)params;
+        } break;
+        case UR_FUNCTION_KERNEL_SET_ARG_LOCAL: {
+            os << (const struct ur_kernel_set_arg_local_params_t *)params;
+        } break;
+        case UR_FUNCTION_KERNEL_SET_ARG_POINTER: {
+            os << (const struct ur_kernel_set_arg_pointer_params_t *)params;
+        } break;
+        case UR_FUNCTION_KERNEL_SET_EXEC_INFO: {
+            os << (const struct ur_kernel_set_exec_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_KERNEL_SET_ARG_SAMPLER: {
+            os << (const struct ur_kernel_set_arg_sampler_params_t *)params;
+        } break;
+        case UR_FUNCTION_KERNEL_SET_ARG_MEM_OBJ: {
+            os << (const struct ur_kernel_set_arg_mem_obj_params_t *)params;
+        } break;
+        case UR_FUNCTION_KERNEL_SET_SPECIALIZATION_CONSTANTS: {
+            os << (const struct ur_kernel_set_specialization_constants_params_t *)params;
+        } break;
+        case UR_FUNCTION_KERNEL_SUGGEST_MAX_COOPERATIVE_GROUP_COUNT_EXP: {
+            os << (const struct ur_kernel_suggest_max_cooperative_group_count_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_QUEUE_GET_INFO: {
+            os << (const struct ur_queue_get_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_QUEUE_CREATE: {
+            os << (const struct ur_queue_create_params_t *)params;
+        } break;
+        case UR_FUNCTION_QUEUE_RETAIN: {
+            os << (const struct ur_queue_retain_params_t *)params;
+        } break;
+        case UR_FUNCTION_QUEUE_RELEASE: {
+            os << (const struct ur_queue_release_params_t *)params;
+        } break;
+        case UR_FUNCTION_QUEUE_GET_NATIVE_HANDLE: {
+            os << (const struct ur_queue_get_native_handle_params_t *)params;
+        } break;
+        case UR_FUNCTION_QUEUE_CREATE_WITH_NATIVE_HANDLE: {
+            os << (const struct ur_queue_create_with_native_handle_params_t *)params;
+        } break;
+        case UR_FUNCTION_QUEUE_FINISH: {
+            os << (const struct ur_queue_finish_params_t *)params;
+        } break;
+        case UR_FUNCTION_QUEUE_FLUSH: {
+            os << (const struct ur_queue_flush_params_t *)params;
+        } break;
+        case UR_FUNCTION_SAMPLER_CREATE: {
+            os << (const struct ur_sampler_create_params_t *)params;
+        } break;
+        case UR_FUNCTION_SAMPLER_RETAIN: {
+            os << (const struct ur_sampler_retain_params_t *)params;
+        } break;
+        case UR_FUNCTION_SAMPLER_RELEASE: {
+            os << (const struct ur_sampler_release_params_t *)params;
+        } break;
+        case UR_FUNCTION_SAMPLER_GET_INFO: {
+            os << (const struct ur_sampler_get_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_SAMPLER_GET_NATIVE_HANDLE: {
+            os << (const struct ur_sampler_get_native_handle_params_t *)params;
+        } break;
+        case UR_FUNCTION_SAMPLER_CREATE_WITH_NATIVE_HANDLE: {
+            os << (const struct ur_sampler_create_with_native_handle_params_t *)params;
+        } break;
+        case UR_FUNCTION_MEM_IMAGE_CREATE: {
+            os << (const struct ur_mem_image_create_params_t *)params;
+        } break;
+        case UR_FUNCTION_MEM_BUFFER_CREATE: {
+            os << (const struct ur_mem_buffer_create_params_t *)params;
+        } break;
+        case UR_FUNCTION_MEM_RETAIN: {
+            os << (const struct ur_mem_retain_params_t *)params;
+        } break;
+        case UR_FUNCTION_MEM_RELEASE: {
+            os << (const struct ur_mem_release_params_t *)params;
+        } break;
+        case UR_FUNCTION_MEM_BUFFER_PARTITION: {
+            os << (const struct ur_mem_buffer_partition_params_t *)params;
+        } break;
+        case UR_FUNCTION_MEM_GET_NATIVE_HANDLE: {
+            os << (const struct ur_mem_get_native_handle_params_t *)params;
+        } break;
+        case UR_FUNCTION_MEM_BUFFER_CREATE_WITH_NATIVE_HANDLE: {
+            os << (const struct ur_mem_buffer_create_with_native_handle_params_t *)params;
+        } break;
+        case UR_FUNCTION_MEM_IMAGE_CREATE_WITH_NATIVE_HANDLE: {
+            os << (const struct ur_mem_image_create_with_native_handle_params_t *)params;
+        } break;
+        case UR_FUNCTION_MEM_GET_INFO: {
+            os << (const struct ur_mem_get_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_MEM_IMAGE_GET_INFO: {
+            os << (const struct ur_mem_image_get_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_PHYSICAL_MEM_CREATE: {
+            os << (const struct ur_physical_mem_create_params_t *)params;
+        } break;
+        case UR_FUNCTION_PHYSICAL_MEM_RETAIN: {
+            os << (const struct ur_physical_mem_retain_params_t *)params;
+        } break;
+        case UR_FUNCTION_PHYSICAL_MEM_RELEASE: {
+            os << (const struct ur_physical_mem_release_params_t *)params;
+        } break;
+        case UR_FUNCTION_ADAPTER_GET: {
+            os << (const struct ur_adapter_get_params_t *)params;
+        } break;
+        case UR_FUNCTION_ADAPTER_RELEASE: {
+            os << (const struct ur_adapter_release_params_t *)params;
+        } break;
+        case UR_FUNCTION_ADAPTER_RETAIN: {
+            os << (const struct ur_adapter_retain_params_t *)params;
+        } break;
+        case UR_FUNCTION_ADAPTER_GET_LAST_ERROR: {
+            os << (const struct ur_adapter_get_last_error_params_t *)params;
+        } break;
+        case UR_FUNCTION_ADAPTER_GET_INFO: {
+            os << (const struct ur_adapter_get_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH: {
+            os << (const struct ur_enqueue_kernel_launch_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_EVENTS_WAIT: {
+            os << (const struct ur_enqueue_events_wait_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_EVENTS_WAIT_WITH_BARRIER: {
+            os << (const struct ur_enqueue_events_wait_with_barrier_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ: {
+            os << (const struct ur_enqueue_mem_buffer_read_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE: {
+            os << (const struct ur_enqueue_mem_buffer_write_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ_RECT: {
+            os << (const struct ur_enqueue_mem_buffer_read_rect_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE_RECT: {
+            os << (const struct ur_enqueue_mem_buffer_write_rect_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY: {
+            os << (const struct ur_enqueue_mem_buffer_copy_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY_RECT: {
+            os << (const struct ur_enqueue_mem_buffer_copy_rect_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_MEM_BUFFER_FILL: {
+            os << (const struct ur_enqueue_mem_buffer_fill_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_MEM_IMAGE_READ: {
+            os << (const struct ur_enqueue_mem_image_read_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_MEM_IMAGE_WRITE: {
+            os << (const struct ur_enqueue_mem_image_write_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_MEM_IMAGE_COPY: {
+            os << (const struct ur_enqueue_mem_image_copy_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_MEM_BUFFER_MAP: {
+            os << (const struct ur_enqueue_mem_buffer_map_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_MEM_UNMAP: {
+            os << (const struct ur_enqueue_mem_unmap_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_USM_FILL: {
+            os << (const struct ur_enqueue_usm_fill_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_USM_MEMCPY: {
+            os << (const struct ur_enqueue_usm_memcpy_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_USM_PREFETCH: {
+            os << (const struct ur_enqueue_usm_prefetch_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_USM_ADVISE: {
+            os << (const struct ur_enqueue_usm_advise_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_USM_FILL_2D: {
+            os << (const struct ur_enqueue_usm_fill_2d_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_USM_MEMCPY_2D: {
+            os << (const struct ur_enqueue_usm_memcpy_2d_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_WRITE: {
+            os << (const struct ur_enqueue_device_global_variable_write_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_DEVICE_GLOBAL_VARIABLE_READ: {
+            os << (const struct ur_enqueue_device_global_variable_read_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_READ_HOST_PIPE: {
+            os << (const struct ur_enqueue_read_host_pipe_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_WRITE_HOST_PIPE: {
+            os << (const struct ur_enqueue_write_host_pipe_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH_CUSTOM_EXP: {
+            os << (const struct ur_enqueue_kernel_launch_custom_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_COOPERATIVE_KERNEL_LAUNCH_EXP: {
+            os << (const struct ur_enqueue_cooperative_kernel_launch_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_TIMESTAMP_RECORDING_EXP: {
+            os << (const struct ur_enqueue_timestamp_recording_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_ENQUEUE_NATIVE_COMMAND_EXP: {
+            os << (const struct ur_enqueue_native_command_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_HANDLE_DESTROY_EXP: {
+            os << (const struct ur_bindless_images_unsampled_image_handle_destroy_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_HANDLE_DESTROY_EXP: {
+            os << (const struct ur_bindless_images_sampled_image_handle_destroy_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_BINDLESS_IMAGES_IMAGE_ALLOCATE_EXP: {
+            os << (const struct ur_bindless_images_image_allocate_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_BINDLESS_IMAGES_IMAGE_FREE_EXP: {
+            os << (const struct ur_bindless_images_image_free_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_BINDLESS_IMAGES_UNSAMPLED_IMAGE_CREATE_EXP: {
+            os << (const struct ur_bindless_images_unsampled_image_create_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_BINDLESS_IMAGES_SAMPLED_IMAGE_CREATE_EXP: {
+            os << (const struct ur_bindless_images_sampled_image_create_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_BINDLESS_IMAGES_IMAGE_COPY_EXP: {
+            os << (const struct ur_bindless_images_image_copy_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_BINDLESS_IMAGES_IMAGE_GET_INFO_EXP: {
+            os << (const struct ur_bindless_images_image_get_info_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_GET_LEVEL_EXP: {
+            os << (const struct ur_bindless_images_mipmap_get_level_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_BINDLESS_IMAGES_MIPMAP_FREE_EXP: {
+            os << (const struct ur_bindless_images_mipmap_free_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_MEMORY_EXP: {
+            os << (const struct ur_bindless_images_import_external_memory_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_ARRAY_EXP: {
+            os << (const struct ur_bindless_images_map_external_array_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_BINDLESS_IMAGES_MAP_EXTERNAL_LINEAR_MEMORY_EXP: {
+            os << (const struct ur_bindless_images_map_external_linear_memory_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_MEMORY_EXP: {
+            os << (const struct ur_bindless_images_release_external_memory_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_BINDLESS_IMAGES_IMPORT_EXTERNAL_SEMAPHORE_EXP: {
+            os << (const struct ur_bindless_images_import_external_semaphore_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_BINDLESS_IMAGES_RELEASE_EXTERNAL_SEMAPHORE_EXP: {
+            os << (const struct ur_bindless_images_release_external_semaphore_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_BINDLESS_IMAGES_WAIT_EXTERNAL_SEMAPHORE_EXP: {
+            os << (const struct ur_bindless_images_wait_external_semaphore_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_BINDLESS_IMAGES_SIGNAL_EXTERNAL_SEMAPHORE_EXP: {
+            os << (const struct ur_bindless_images_signal_external_semaphore_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_USM_HOST_ALLOC: {
+            os << (const struct ur_usm_host_alloc_params_t *)params;
+        } break;
+        case UR_FUNCTION_USM_DEVICE_ALLOC: {
+            os << (const struct ur_usm_device_alloc_params_t *)params;
+        } break;
+        case UR_FUNCTION_USM_SHARED_ALLOC: {
+            os << (const struct ur_usm_shared_alloc_params_t *)params;
+        } break;
+        case UR_FUNCTION_USM_FREE: {
+            os << (const struct ur_usm_free_params_t *)params;
+        } break;
+        case UR_FUNCTION_USM_GET_MEM_ALLOC_INFO: {
+            os << (const struct ur_usm_get_mem_alloc_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_USM_POOL_CREATE: {
+            os << (const struct ur_usm_pool_create_params_t *)params;
+        } break;
+        case UR_FUNCTION_USM_POOL_RETAIN: {
+            os << (const struct ur_usm_pool_retain_params_t *)params;
+        } break;
+        case UR_FUNCTION_USM_POOL_RELEASE: {
+            os << (const struct ur_usm_pool_release_params_t *)params;
+        } break;
+        case UR_FUNCTION_USM_POOL_GET_INFO: {
+            os << (const struct ur_usm_pool_get_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_USM_PITCHED_ALLOC_EXP: {
+            os << (const struct ur_usm_pitched_alloc_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_USM_IMPORT_EXP: {
+            os << (const struct ur_usm_import_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_USM_RELEASE_EXP: {
+            os << (const struct ur_usm_release_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_CREATE_EXP: {
+            os << (const struct ur_command_buffer_create_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_RETAIN_EXP: {
+            os << (const struct ur_command_buffer_retain_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_RELEASE_EXP: {
+            os << (const struct ur_command_buffer_release_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_FINALIZE_EXP: {
+            os << (const struct ur_command_buffer_finalize_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_APPEND_KERNEL_LAUNCH_EXP: {
+            os << (const struct ur_command_buffer_append_kernel_launch_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_MEMCPY_EXP: {
+            os << (const struct ur_command_buffer_append_usm_memcpy_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_FILL_EXP: {
+            os << (const struct ur_command_buffer_append_usm_fill_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_EXP: {
+            os << (const struct ur_command_buffer_append_mem_buffer_copy_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_EXP: {
+            os << (const struct ur_command_buffer_append_mem_buffer_write_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_EXP: {
+            os << (const struct ur_command_buffer_append_mem_buffer_read_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_COPY_RECT_EXP: {
+            os << (const struct ur_command_buffer_append_mem_buffer_copy_rect_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_WRITE_RECT_EXP: {
+            os << (const struct ur_command_buffer_append_mem_buffer_write_rect_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_READ_RECT_EXP: {
+            os << (const struct ur_command_buffer_append_mem_buffer_read_rect_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_APPEND_MEM_BUFFER_FILL_EXP: {
+            os << (const struct ur_command_buffer_append_mem_buffer_fill_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_PREFETCH_EXP: {
+            os << (const struct ur_command_buffer_append_usm_prefetch_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_APPEND_USM_ADVISE_EXP: {
+            os << (const struct ur_command_buffer_append_usm_advise_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_ENQUEUE_EXP: {
+            os << (const struct ur_command_buffer_enqueue_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_RETAIN_COMMAND_EXP: {
+            os << (const struct ur_command_buffer_retain_command_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_RELEASE_COMMAND_EXP: {
+            os << (const struct ur_command_buffer_release_command_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_UPDATE_KERNEL_LAUNCH_EXP: {
+            os << (const struct ur_command_buffer_update_kernel_launch_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_UPDATE_SIGNAL_EVENT_EXP: {
+            os << (const struct ur_command_buffer_update_signal_event_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_UPDATE_WAIT_EVENTS_EXP: {
+            os << (const struct ur_command_buffer_update_wait_events_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_GET_INFO_EXP: {
+            os << (const struct ur_command_buffer_get_info_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_COMMAND_BUFFER_COMMAND_GET_INFO_EXP: {
+            os << (const struct ur_command_buffer_command_get_info_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_USM_P2P_ENABLE_PEER_ACCESS_EXP: {
+            os << (const struct ur_usm_p2p_enable_peer_access_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_USM_P2P_DISABLE_PEER_ACCESS_EXP: {
+            os << (const struct ur_usm_p2p_disable_peer_access_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_USM_P2P_PEER_ACCESS_GET_INFO_EXP: {
+            os << (const struct ur_usm_p2p_peer_access_get_info_exp_params_t *)params;
+        } break;
+        case UR_FUNCTION_LOADER_INIT: {
+            os << (const struct ur_loader_init_params_t *)params;
+        } break;
+        case UR_FUNCTION_LOADER_TEAR_DOWN: {
+            os << (const struct ur_loader_tear_down_params_t *)params;
+        } break;
+        case UR_FUNCTION_VIRTUAL_MEM_GRANULARITY_GET_INFO: {
+            os << (const struct ur_virtual_mem_granularity_get_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_VIRTUAL_MEM_RESERVE: {
+            os << (const struct ur_virtual_mem_reserve_params_t *)params;
+        } break;
+        case UR_FUNCTION_VIRTUAL_MEM_FREE: {
+            os << (const struct ur_virtual_mem_free_params_t *)params;
+        } break;
+        case UR_FUNCTION_VIRTUAL_MEM_MAP: {
+            os << (const struct ur_virtual_mem_map_params_t *)params;
+        } break;
+        case UR_FUNCTION_VIRTUAL_MEM_UNMAP: {
+            os << (const struct ur_virtual_mem_unmap_params_t *)params;
+        } break;
+        case UR_FUNCTION_VIRTUAL_MEM_SET_ACCESS: {
+            os << (const struct ur_virtual_mem_set_access_params_t *)params;
+        } break;
+        case UR_FUNCTION_VIRTUAL_MEM_GET_INFO: {
+            os << (const struct ur_virtual_mem_get_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_DEVICE_GET: {
+            os << (const struct ur_device_get_params_t *)params;
+        } break;
+        case UR_FUNCTION_DEVICE_GET_SELECTED: {
+            os << (const struct ur_device_get_selected_params_t *)params;
+        } break;
+        case UR_FUNCTION_DEVICE_GET_INFO: {
+            os << (const struct ur_device_get_info_params_t *)params;
+        } break;
+        case UR_FUNCTION_DEVICE_RETAIN: {
+            os << (const struct ur_device_retain_params_t *)params;
+        } break;
+        case UR_FUNCTION_DEVICE_RELEASE: {
+            os << (const struct ur_device_release_params_t *)params;
+        } break;
+        case UR_FUNCTION_DEVICE_PARTITION: {
+            os << (const struct ur_device_partition_params_t *)params;
+        } break;
+        case UR_FUNCTION_DEVICE_SELECT_BINARY: {
+            os << (const struct ur_device_select_binary_params_t *)params;
+        } break;
+        case UR_FUNCTION_DEVICE_GET_NATIVE_HANDLE: {
+            os << (const struct ur_device_get_native_handle_params_t *)params;
+        } break;
+        case UR_FUNCTION_DEVICE_CREATE_WITH_NATIVE_HANDLE: {
+            os << (const struct ur_device_create_with_native_handle_params_t *)params;
+        } break;
+        case UR_FUNCTION_DEVICE_GET_GLOBAL_TIMESTAMPS: {
+            os << (const struct ur_device_get_global_timestamps_params_t *)params;
+        } break;
+        default: return UR_RESULT_ERROR_INVALID_ENUMERATION;
     }
     return UR_RESULT_SUCCESS;
 }
diff --git a/scripts/core/enqueue.yml b/scripts/core/enqueue.yml
index f712dd9021..575dbaebf3 100644
--- a/scripts/core/enqueue.yml
+++ b/scripts/core/enqueue.yml
@@ -847,13 +847,16 @@ etors:
       value: "$X_BIT(2)"
 --- #--------------------------------------------------------------------------
 type: enum
-desc: "Map flags"
+desc: "USM migration flags, indicating the direction data is migrated in"
 class: $xDevice
 name: $x_usm_migration_flags_t
 etors:
-    - name: DEFAULT
-      desc: "Default migration TODO: Add more enums! "
+    - name: HOST_TO_DEVICE
+      desc: "Migrate data from host to device"
       value: "$X_BIT(0)"
+    - name: DEVICE_TO_HOST
+      desc: "Migrate data from device to host"
+      value: "$X_BIT(1)"
 --- #--------------------------------------------------------------------------
 type: function
 desc: "Enqueue a command to map a region of the buffer object into the host address space and return a pointer to the mapped region"
@@ -1141,7 +1144,7 @@ params:
       desc: "[in] size in bytes to be fetched"
     - type: $x_usm_migration_flags_t
       name: flags
-      desc: "[in] USM prefetch flags"
+      desc: "[in] USM migration flags"
     - type: uint32_t
       name: numEventsInWaitList
       desc: "[in] size of the event wait list"
diff --git a/scripts/core/exp-command-buffer.yml b/scripts/core/exp-command-buffer.yml
index 5305ab264f..517d589251 100644
--- a/scripts/core/exp-command-buffer.yml
+++ b/scripts/core/exp-command-buffer.yml
@@ -1012,7 +1012,7 @@ params:
       desc: "[in] size in bytes to be fetched."
     - type: $x_usm_migration_flags_t
       name: flags
-      desc: "[in] USM prefetch flags"
+      desc: "[in] USM migration flags"
     - type: uint32_t
       name: numSyncPointsInWaitList
       desc: "[in] The number of sync points in the provided dependency list."
diff --git a/source/ur_api.cpp b/source/ur_api.cpp
index cdfdb648af..f90970a8ad 100644
--- a/source/ur_api.cpp
+++ b/source/ur_api.cpp
@@ -14,7 +14,7 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create a loader config object.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -22,23 +22,24 @@
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_POINTER
 ///         + `NULL == phLoaderConfig`
-ur_result_t UR_APICALL urLoaderConfigCreate(
-    ur_loader_config_handle_t *
-        phLoaderConfig ///< [out] Pointer to handle of loader config object created.
-) {
+ur_result_t UR_APICALL
+urLoaderConfigCreate(
+    ur_loader_config_handle_t* phLoaderConfig       ///< [out] Pointer to handle of loader config object created.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Get a reference to the loader config object.
-///
+/// 
 /// @details
 ///     - Get a reference to the loader config handle. Increment its reference
 ///       count
 ///     - The application may call this function from simultaneous threads.
 ///     - The implementation of this function should be lock-free.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -46,23 +47,24 @@ ur_result_t UR_APICALL urLoaderConfigCreate(
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE
 ///         + `NULL == hLoaderConfig`
-ur_result_t UR_APICALL urLoaderConfigRetain(
-    ur_loader_config_handle_t
-        hLoaderConfig ///< [in][retain] loader config handle to retain
-) {
+ur_result_t UR_APICALL
+urLoaderConfigRetain(
+    ur_loader_config_handle_t hLoaderConfig         ///< [in][retain] loader config handle to retain
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Release config handle.
-///
+/// 
 /// @details
 ///     - Decrement reference count and destroy the config handle if reference
 ///       count becomes zero.
 ///     - The application may call this function from simultaneous threads.
 ///     - The implementation of this function should be lock-free.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -70,21 +72,22 @@ ur_result_t UR_APICALL urLoaderConfigRetain(
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE
 ///         + `NULL == hLoaderConfig`
-ur_result_t UR_APICALL urLoaderConfigRelease(
-    ur_loader_config_handle_t
-        hLoaderConfig ///< [in][release] config handle to release
-) {
+ur_result_t UR_APICALL
+urLoaderConfigRelease(
+    ur_loader_config_handle_t hLoaderConfig         ///< [in][release] config handle to release
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Retrieves various information about the loader.
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads.
 ///     - The implementation of this function should be lock-free.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -105,28 +108,27 @@ ur_result_t UR_APICALL urLoaderConfigRelease(
 ///     - ::UR_RESULT_ERROR_INVALID_DEVICE
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urLoaderConfigGetInfo(
-    ur_loader_config_handle_t
-        hLoaderConfig, ///< [in] handle of the loader config object
-    ur_loader_config_info_t propName, ///< [in] type of the info to retrieve
-    size_t propSize, ///< [in] the number of bytes pointed to by pPropValue.
-    void *
-        pPropValue, ///< [out][optional][typename(propName, propSize)] array of bytes holding
-                    ///< the info.
-    ///< If propSize is not equal to or greater than the real number of bytes
-    ///< needed to return the info
-    ///< then the ::UR_RESULT_ERROR_INVALID_SIZE error is returned and
-    ///< pPropValue is not used.
-    size_t *
-        pPropSizeRet ///< [out][optional] pointer to the actual size in bytes of the queried propName.
-) {
+ur_result_t UR_APICALL
+urLoaderConfigGetInfo(
+    ur_loader_config_handle_t hLoaderConfig,        ///< [in] handle of the loader config object
+    ur_loader_config_info_t propName,               ///< [in] type of the info to retrieve
+    size_t propSize,                                ///< [in] the number of bytes pointed to by pPropValue.
+    void* pPropValue,                               ///< [out][optional][typename(propName, propSize)] array of bytes holding
+                                                    ///< the info.
+                                                    ///< If propSize is not equal to or greater than the real number of bytes
+                                                    ///< needed to return the info
+                                                    ///< then the ::UR_RESULT_ERROR_INVALID_SIZE error is returned and
+                                                    ///< pPropValue is not used.
+    size_t* pPropSizeRet                            ///< [out][optional] pointer to the actual size in bytes of the queried propName.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enable a layer for the specified loader config.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -138,13 +140,13 @@ ur_result_t UR_APICALL urLoaderConfigGetInfo(
 ///         + `NULL == pLayerName`
 ///     - ::UR_RESULT_ERROR_LAYER_NOT_PRESENT
 ///         + If layer specified with `pLayerName` can't be found by the loader.
-ur_result_t UR_APICALL urLoaderConfigEnableLayer(
-    ur_loader_config_handle_t
-        hLoaderConfig, ///< [in] Handle to config object the layer will be enabled for.
-    const char *
-        pLayerName ///< [in] Null terminated string containing the name of the layer to
-                   ///< enable. Empty if none are enabled.
-) {
+ur_result_t UR_APICALL
+urLoaderConfigEnableLayer(
+    ur_loader_config_handle_t hLoaderConfig,        ///< [in] Handle to config object the layer will be enabled for.
+    const char* pLayerName                          ///< [in] Null terminated string containing the name of the layer to
+                                                    ///< enable. Empty if none are enabled.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -152,14 +154,14 @@ ur_result_t UR_APICALL urLoaderConfigEnableLayer(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Set a function callback for use by the loader to retrieve code
 ///        location information.
-///
+/// 
 /// @details
 ///     - The code location callback is optional and provides additional
 ///       information to the tracing layer about the entry point of the current
 ///       execution flow.
 ///     - This functionality can be used to match traced unified runtime
 ///       function calls with higher-level user calls.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -169,28 +171,27 @@ ur_result_t UR_APICALL urLoaderConfigEnableLayer(
 ///         + `NULL == hLoaderConfig`
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_POINTER
 ///         + `NULL == pfnCodeloc`
-ur_result_t UR_APICALL urLoaderConfigSetCodeLocationCallback(
-    ur_loader_config_handle_t
-        hLoaderConfig, ///< [in] Handle to config object the layer will be enabled for.
-    ur_code_location_callback_t
-        pfnCodeloc, ///< [in] Function pointer to code location callback.
-    void *
-        pUserData ///< [in][out][optional] pointer to data to be passed to callback.
-) {
+ur_result_t UR_APICALL
+urLoaderConfigSetCodeLocationCallback(
+    ur_loader_config_handle_t hLoaderConfig,        ///< [in] Handle to config object the layer will be enabled for.
+    ur_code_location_callback_t pfnCodeloc,         ///< [in] Function pointer to code location callback.
+    void* pUserData                                 ///< [in][out][optional] pointer to data to be passed to callback.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief The only adapter reported with mock enabled will be the mock adapter.
-///
+/// 
 /// @details
 ///     - The mock adapter will default to returning ::UR_RESULT_SUCCESS for all
 ///       entry points. It will also create and correctly reference count dummy
 ///       handles where appropriate. Its behaviour can be modified by linking
 ///       the mock library and using the object accessed via
 ///       mock::getCallbacks().
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -198,19 +199,19 @@ ur_result_t UR_APICALL urLoaderConfigSetCodeLocationCallback(
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE
 ///         + `NULL == hLoaderConfig`
-ur_result_t UR_APICALL urLoaderConfigSetMockingEnabled(
-    ur_loader_config_handle_t
-        hLoaderConfig, ///< [in] Handle to config object mocking will be enabled for.
-    ur_bool_t
-        enable ///< [in] Handle to config object the layer will be enabled for.
-) {
+ur_result_t UR_APICALL
+urLoaderConfigSetMockingEnabled(
+    ur_loader_config_handle_t hLoaderConfig,        ///< [in] Handle to config object mocking will be enabled for.
+    ur_bool_t enable                                ///< [in] Handle to config object the layer will be enabled for.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Initialize the 'oneAPI' loader
-///
+/// 
 /// @details
 ///     - The application must call this function before calling any other
 ///       function.
@@ -224,7 +225,7 @@ ur_result_t UR_APICALL urLoaderConfigSetMockingEnabled(
 ///     - The application may call this function from simultaneous threads.
 ///     - The implementation of this function must be thread-safe for scenarios
 ///       where multiple libraries may initialize the loader simultaneously.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -233,33 +234,38 @@ ur_result_t UR_APICALL urLoaderConfigSetMockingEnabled(
 ///     - ::UR_RESULT_ERROR_INVALID_ENUMERATION
 ///         + `::UR_DEVICE_INIT_FLAGS_MASK & device_flags`
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urLoaderInit(
-    ur_device_init_flags_t device_flags, ///< [in] device initialization flags.
-    ///< must be 0 (default) or a combination of ::ur_device_init_flag_t.
-    ur_loader_config_handle_t
-        hLoaderConfig ///< [in][optional] Handle of loader config handle.
-) {
+ur_result_t UR_APICALL
+urLoaderInit(
+    ur_device_init_flags_t device_flags,            ///< [in] device initialization flags.
+                                                    ///< must be 0 (default) or a combination of ::ur_device_init_flag_t.
+    ur_loader_config_handle_t hLoaderConfig         ///< [in][optional] Handle of loader config handle.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Tear down the 'oneAPI' loader and release all its resources
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
 ///     - ::UR_RESULT_ERROR_DEVICE_LOST
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urLoaderTearDown(void) {
+ur_result_t UR_APICALL
+urLoaderTearDown(
+    void
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Retrieves all available adapters
-///
+/// 
 /// @details
 ///     - Adapter implementations must return exactly one adapter handle from
 ///       this entry point.
@@ -271,7 +277,7 @@ ur_result_t UR_APICALL urLoaderTearDown(void) {
 ///       first reference to them is taken.
 ///     - An application may call this entry point multiple times to acquire
 ///       multiple references to the adapter handle(s).
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -279,32 +285,31 @@ ur_result_t UR_APICALL urLoaderTearDown(void) {
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         + `NumEntries == 0 && phAdapters != NULL`
-ur_result_t UR_APICALL urAdapterGet(
-    uint32_t
-        NumEntries, ///< [in] the number of adapters to be added to phAdapters.
-    ///< If phAdapters is not NULL, then NumEntries should be greater than
-    ///< zero, otherwise ::UR_RESULT_ERROR_INVALID_SIZE,
-    ///< will be returned.
-    ur_adapter_handle_t *
-        phAdapters, ///< [out][optional][range(0, NumEntries)] array of handle of adapters.
-    ///< If NumEntries is less than the number of adapters available, then
-    ///< ::urAdapterGet shall only retrieve that number of adapters.
-    uint32_t *
-        pNumAdapters ///< [out][optional] returns the total number of adapters available.
-) {
+ur_result_t UR_APICALL
+urAdapterGet(
+    uint32_t NumEntries,                            ///< [in] the number of adapters to be added to phAdapters.
+                                                    ///< If phAdapters is not NULL, then NumEntries should be greater than
+                                                    ///< zero, otherwise ::UR_RESULT_ERROR_INVALID_SIZE,
+                                                    ///< will be returned.
+    ur_adapter_handle_t* phAdapters,                ///< [out][optional][range(0, NumEntries)] array of handle of adapters.
+                                                    ///< If NumEntries is less than the number of adapters available, then
+                                                    ///< ::urAdapterGet shall only retrieve that number of adapters.
+    uint32_t* pNumAdapters                          ///< [out][optional] returns the total number of adapters available.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Releases the adapter handle reference indicating end of its usage
-///
+/// 
 /// @details
 ///     - When the reference count of the adapter reaches zero, the adapter may
 ///       perform adapter-specififc resource teardown. Resources must be left in
 ///       a state where it safe for the adapter to be subsequently reinitialized
 ///       with ::urAdapterGet
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -312,19 +317,21 @@ ur_result_t UR_APICALL urAdapterGet(
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE
 ///         + `NULL == hAdapter`
-ur_result_t UR_APICALL urAdapterRelease(
-    ur_adapter_handle_t hAdapter ///< [in][release] Adapter handle to release
-) {
+ur_result_t UR_APICALL
+urAdapterRelease(
+    ur_adapter_handle_t hAdapter                    ///< [in][release] Adapter handle to release
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Get a reference to the adapter handle.
-///
+/// 
 /// @details
 ///     - Get a reference to the adapter handle. Increment its reference count
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -332,37 +339,39 @@ ur_result_t UR_APICALL urAdapterRelease(
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE
 ///         + `NULL == hAdapter`
-ur_result_t UR_APICALL urAdapterRetain(
-    ur_adapter_handle_t hAdapter ///< [in][retain] Adapter handle to retain
-) {
+ur_result_t UR_APICALL
+urAdapterRetain(
+    ur_adapter_handle_t hAdapter                    ///< [in][retain] Adapter handle to retain
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Get the last adapter specific error.
-///
+/// 
 /// @details
 /// To be used after another entry-point has returned
 /// ::UR_RESULT_ERROR_ADAPTER_SPECIFIC in order to retrieve a message describing
 /// the circumstances of the underlying driver error and the error code
 /// returned by the failed driver entry-point.
-///
+/// 
 /// * Implementations *must* store the message and error code in thread-local
 ///   storage prior to returning ::UR_RESULT_ERROR_ADAPTER_SPECIFIC.
-///
+/// 
 /// * The message and error code storage is will only be valid if a previously
 ///   called entry-point returned ::UR_RESULT_ERROR_ADAPTER_SPECIFIC.
-///
+/// 
 /// * The memory pointed to by the C string returned in `ppMessage` is owned by
 ///   the adapter and *must* be null terminated.
-///
+/// 
 /// * The application *may* call this function from simultaneous threads.
-///
+/// 
 /// * The implementation of this function *should* be lock-free.
-///
+/// 
 /// Example usage:
-///
+/// 
 /// ```cpp
 /// if (::urQueueCreate(hContext, hDevice, nullptr, &hQueue) ==
 ///         ::UR_RESULT_ERROR_ADAPTER_SPECIFIC) {
@@ -371,7 +380,7 @@ ur_result_t UR_APICALL urAdapterRetain(
 ///     ::urAdapterGetLastError(hAdapter, &pMessage, &error);
 /// }
 /// ```
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -382,26 +391,26 @@ ur_result_t UR_APICALL urAdapterRetain(
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_POINTER
 ///         + `NULL == ppMessage`
 ///         + `NULL == pError`
-ur_result_t UR_APICALL urAdapterGetLastError(
-    ur_adapter_handle_t hAdapter, ///< [in] handle of the adapter instance
-    const char **
-        ppMessage, ///< [out] pointer to a C string where the adapter specific error message
-                   ///< will be stored.
-    int32_t *
-        pError ///< [out] pointer to an integer where the adapter specific error code will
-               ///< be stored.
-) {
+ur_result_t UR_APICALL
+urAdapterGetLastError(
+    ur_adapter_handle_t hAdapter,                   ///< [in] handle of the adapter instance
+    const char** ppMessage,                         ///< [out] pointer to a C string where the adapter specific error message
+                                                    ///< will be stored.
+    int32_t* pError                                 ///< [out] pointer to an integer where the adapter specific error code will
+                                                    ///< be stored.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Retrieves information about the adapter
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads.
 ///     - The implementation of this function should be lock-free.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -421,36 +430,36 @@ ur_result_t UR_APICALL urAdapterGetLastError(
 ///         + `pPropValue == NULL && pPropSizeRet == NULL`
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urAdapterGetInfo(
-    ur_adapter_handle_t hAdapter, ///< [in] handle of the adapter
-    ur_adapter_info_t propName,   ///< [in] type of the info to retrieve
-    size_t propSize, ///< [in] the number of bytes pointed to by pPropValue.
-    void *
-        pPropValue, ///< [out][optional][typename(propName, propSize)] array of bytes holding
-                    ///< the info.
-    ///< If Size is not equal to or greater to the real number of bytes needed
-    ///< to return the info then the ::UR_RESULT_ERROR_INVALID_SIZE error is
-    ///< returned and pPropValue is not used.
-    size_t *
-        pPropSizeRet ///< [out][optional] pointer to the actual number of bytes being queried by pPropValue.
-) {
+ur_result_t UR_APICALL
+urAdapterGetInfo(
+    ur_adapter_handle_t hAdapter,                   ///< [in] handle of the adapter
+    ur_adapter_info_t propName,                     ///< [in] type of the info to retrieve
+    size_t propSize,                                ///< [in] the number of bytes pointed to by pPropValue.
+    void* pPropValue,                               ///< [out][optional][typename(propName, propSize)] array of bytes holding
+                                                    ///< the info.
+                                                    ///< If Size is not equal to or greater to the real number of bytes needed
+                                                    ///< to return the info then the ::UR_RESULT_ERROR_INVALID_SIZE error is
+                                                    ///< returned and pPropValue is not used.
+    size_t* pPropSizeRet                            ///< [out][optional] pointer to the actual number of bytes being queried by pPropValue.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Retrieves all available platforms for the given adapters
-///
+/// 
 /// @details
 ///     - Multiple calls to this function will return identical platforms
 ///       handles, in the same order.
 ///     - The application may call this function from simultaneous threads, the
 ///       implementation must be thread-safe
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clGetPlatformIDs**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -460,37 +469,35 @@ ur_result_t UR_APICALL urAdapterGetInfo(
 ///         + `NULL == phAdapters`
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         + `NumEntries == 0 && phPlatforms != NULL`
-ur_result_t UR_APICALL urPlatformGet(
-    ur_adapter_handle_t *
-        phAdapters, ///< [in][range(0, NumAdapters)] array of adapters to query for platforms.
-    uint32_t NumAdapters, ///< [in] number of adapters pointed to by phAdapters
-    uint32_t
-        NumEntries, ///< [in] the number of platforms to be added to phPlatforms.
-    ///< If phPlatforms is not NULL, then NumEntries should be greater than
-    ///< zero, otherwise ::UR_RESULT_ERROR_INVALID_SIZE,
-    ///< will be returned.
-    ur_platform_handle_t *
-        phPlatforms, ///< [out][optional][range(0, NumEntries)] array of handle of platforms.
-    ///< If NumEntries is less than the number of platforms available, then
-    ///< ::urPlatformGet shall only retrieve that number of platforms.
-    uint32_t *
-        pNumPlatforms ///< [out][optional] returns the total number of platforms available.
-) {
+ur_result_t UR_APICALL
+urPlatformGet(
+    ur_adapter_handle_t* phAdapters,                ///< [in][range(0, NumAdapters)] array of adapters to query for platforms.
+    uint32_t NumAdapters,                           ///< [in] number of adapters pointed to by phAdapters
+    uint32_t NumEntries,                            ///< [in] the number of platforms to be added to phPlatforms.
+                                                    ///< If phPlatforms is not NULL, then NumEntries should be greater than
+                                                    ///< zero, otherwise ::UR_RESULT_ERROR_INVALID_SIZE,
+                                                    ///< will be returned.
+    ur_platform_handle_t* phPlatforms,              ///< [out][optional][range(0, NumEntries)] array of handle of platforms.
+                                                    ///< If NumEntries is less than the number of platforms available, then
+                                                    ///< ::urPlatformGet shall only retrieve that number of platforms.
+    uint32_t* pNumPlatforms                         ///< [out][optional] returns the total number of platforms available.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Retrieves various information about platform
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads.
 ///     - The implementation of this function should be lock-free.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clGetPlatformInfo**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -511,30 +518,30 @@ ur_result_t UR_APICALL urPlatformGet(
 ///     - ::UR_RESULT_ERROR_INVALID_PLATFORM
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urPlatformGetInfo(
-    ur_platform_handle_t hPlatform, ///< [in] handle of the platform
-    ur_platform_info_t propName,    ///< [in] type of the info to retrieve
-    size_t propSize, ///< [in] the number of bytes pointed to by pPlatformInfo.
-    void *
-        pPropValue, ///< [out][optional][typename(propName, propSize)] array of bytes holding
-                    ///< the info.
-    ///< If Size is not equal to or greater to the real number of bytes needed
-    ///< to return the info then the ::UR_RESULT_ERROR_INVALID_SIZE error is
-    ///< returned and pPlatformInfo is not used.
-    size_t *
-        pPropSizeRet ///< [out][optional] pointer to the actual number of bytes being queried by pPlatformInfo.
-) {
+ur_result_t UR_APICALL
+urPlatformGetInfo(
+    ur_platform_handle_t hPlatform,                 ///< [in] handle of the platform
+    ur_platform_info_t propName,                    ///< [in] type of the info to retrieve
+    size_t propSize,                                ///< [in] the number of bytes pointed to by pPlatformInfo.
+    void* pPropValue,                               ///< [out][optional][typename(propName, propSize)] array of bytes holding
+                                                    ///< the info.
+                                                    ///< If Size is not equal to or greater to the real number of bytes needed
+                                                    ///< to return the info then the ::UR_RESULT_ERROR_INVALID_SIZE error is
+                                                    ///< returned and pPlatformInfo is not used.
+    size_t* pPropSizeRet                            ///< [out][optional] pointer to the actual number of bytes being queried by pPlatformInfo.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Returns the API version supported by the specified platform
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads.
 ///     - The implementation of this function should be lock-free.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -544,17 +551,19 @@ ur_result_t UR_APICALL urPlatformGetInfo(
 ///         + `NULL == hPlatform`
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_POINTER
 ///         + `NULL == pVersion`
-ur_result_t UR_APICALL urPlatformGetApiVersion(
-    ur_platform_handle_t hPlatform, ///< [in] handle of the platform
-    ur_api_version_t *pVersion      ///< [out] api version
-) {
+ur_result_t UR_APICALL
+urPlatformGetApiVersion(
+    ur_platform_handle_t hPlatform,                 ///< [in] handle of the platform
+    ur_api_version_t* pVersion                      ///< [out] api version
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Return platform native platform handle.
-///
+/// 
 /// @details
 ///     - Retrieved native handle can be used for direct interaction with the
 ///       native platform driver.
@@ -563,7 +572,7 @@ ur_result_t UR_APICALL urPlatformGetApiVersion(
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -575,24 +584,25 @@ ur_result_t UR_APICALL urPlatformGetApiVersion(
 ///         + `NULL == phNativePlatform`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 ///         + If the adapter has no underlying equivalent handle.
-ur_result_t UR_APICALL urPlatformGetNativeHandle(
-    ur_platform_handle_t hPlatform, ///< [in] handle of the platform.
-    ur_native_handle_t *
-        phNativePlatform ///< [out] a pointer to the native handle of the platform.
-) {
+ur_result_t UR_APICALL
+urPlatformGetNativeHandle(
+    ur_platform_handle_t hPlatform,                 ///< [in] handle of the platform.
+    ur_native_handle_t* phNativePlatform            ///< [out] a pointer to the native handle of the platform.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create runtime platform object from native platform handle.
-///
+/// 
 /// @details
 ///     - Creates runtime platform handle from native driver platform handle.
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -604,16 +614,14 @@ ur_result_t UR_APICALL urPlatformGetNativeHandle(
 ///         + `NULL == phPlatform`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 ///         + If the adapter has no underlying equivalent handle.
-ur_result_t UR_APICALL urPlatformCreateWithNativeHandle(
-    ur_native_handle_t
-        hNativePlatform, ///< [in][nocheck] the native handle of the platform.
-    ur_adapter_handle_t
-        hAdapter, ///< [in] handle of the adapter associated with the native backend.
-    const ur_platform_native_properties_t *
-        pProperties, ///< [in][optional] pointer to native platform properties struct.
-    ur_platform_handle_t *
-        phPlatform ///< [out] pointer to the handle of the platform object created.
-) {
+ur_result_t UR_APICALL
+urPlatformCreateWithNativeHandle(
+    ur_native_handle_t hNativePlatform,             ///< [in][nocheck] the native handle of the platform.
+    ur_adapter_handle_t hAdapter,                   ///< [in] handle of the adapter associated with the native backend.
+    const ur_platform_native_properties_t* pProperties, ///< [in][optional] pointer to native platform properties struct.
+    ur_platform_handle_t* phPlatform                ///< [out] pointer to the handle of the platform object created.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -621,7 +629,7 @@ ur_result_t UR_APICALL urPlatformCreateWithNativeHandle(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Get the platform specific compiler backend option from a generic
 ///        frontend option.
-///
+/// 
 /// @details
 ///     - The string returned via the ppPlatformOption is a NULL terminated C
 ///       style string.
@@ -630,7 +638,7 @@ ur_result_t UR_APICALL urPlatformCreateWithNativeHandle(
 ///       the adapter.
 ///     - The application may call this function from simultaneous threads.
 ///     - The implementation of this function should be lock-free.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -643,21 +651,21 @@ ur_result_t UR_APICALL urPlatformCreateWithNativeHandle(
 ///         + `NULL == ppPlatformOption`
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
 ///         + If `pFrontendOption` is not a valid frontend option.
-ur_result_t UR_APICALL urPlatformGetBackendOption(
-    ur_platform_handle_t hPlatform, ///< [in] handle of the platform instance.
-    const char
-        *pFrontendOption, ///< [in] string containing the frontend option.
-    const char **
-        ppPlatformOption ///< [out] returns the correct platform specific compiler option based on
-                         ///< the frontend option.
-) {
+ur_result_t UR_APICALL
+urPlatformGetBackendOption(
+    ur_platform_handle_t hPlatform,                 ///< [in] handle of the platform instance.
+    const char* pFrontendOption,                    ///< [in] string containing the frontend option.
+    const char** ppPlatformOption                   ///< [out] returns the correct platform specific compiler option based on
+                                                    ///< the frontend option.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Retrieves devices within a platform
-///
+/// 
 /// @details
 ///     - Multiple calls to this function will return identical device handles,
 ///       in the same order.
@@ -668,11 +676,11 @@ ur_result_t UR_APICALL urPlatformGetBackendOption(
 ///       with a subsequent call to ::urDeviceRelease.
 ///     - The application may call this function from simultaneous threads, the
 ///       implementation must be thread-safe
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clGetDeviceIDs**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -687,28 +695,28 @@ ur_result_t UR_APICALL urPlatformGetBackendOption(
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_POINTER
 ///         + `NumEntries > 0 && phDevices == NULL`
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
-ur_result_t UR_APICALL urDeviceGet(
-    ur_platform_handle_t hPlatform, ///< [in] handle of the platform instance
-    ur_device_type_t DeviceType,    ///< [in] the type of the devices.
-    uint32_t
-        NumEntries, ///< [in] the number of devices to be added to phDevices.
-    ///< If phDevices is not NULL, then NumEntries should be greater than zero.
-    ///< Otherwise ::UR_RESULT_ERROR_INVALID_SIZE
-    ///< will be returned.
-    ur_device_handle_t *
-        phDevices, ///< [out][optional][range(0, NumEntries)] array of handle of devices.
-    ///< If NumEntries is less than the number of devices available, then
-    ///< platform shall only retrieve that number of devices.
-    uint32_t *pNumDevices ///< [out][optional] pointer to the number of devices.
-    ///< pNumDevices will be updated with the total number of devices available.
-) {
+ur_result_t UR_APICALL
+urDeviceGet(
+    ur_platform_handle_t hPlatform,                 ///< [in] handle of the platform instance
+    ur_device_type_t DeviceType,                    ///< [in] the type of the devices.
+    uint32_t NumEntries,                            ///< [in] the number of devices to be added to phDevices.
+                                                    ///< If phDevices is not NULL, then NumEntries should be greater than zero.
+                                                    ///< Otherwise ::UR_RESULT_ERROR_INVALID_SIZE
+                                                    ///< will be returned.
+    ur_device_handle_t* phDevices,                  ///< [out][optional][range(0, NumEntries)] array of handle of devices.
+                                                    ///< If NumEntries is less than the number of devices available, then
+                                                    ///< platform shall only retrieve that number of devices.
+    uint32_t* pNumDevices                           ///< [out][optional] pointer to the number of devices.
+                                                    ///< pNumDevices will be updated with the total number of devices available.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Retrieves devices within a platform selected by ONEAPI_DEVICE_SELECTOR
-///
+/// 
 /// @details
 ///     - Multiple calls to this function will return identical device handles,
 ///       in the same order.
@@ -719,7 +727,7 @@ ur_result_t UR_APICALL urDeviceGet(
 ///       with a subsequent call to ::urDeviceRelease.
 ///     - The application may call this function from simultaneous threads, the
 ///       implementation must be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -730,37 +738,37 @@ ur_result_t UR_APICALL urDeviceGet(
 ///     - ::UR_RESULT_ERROR_INVALID_ENUMERATION
 ///         + `::UR_DEVICE_TYPE_VPU < DeviceType`
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
-ur_result_t UR_APICALL urDeviceGetSelected(
-    ur_platform_handle_t hPlatform, ///< [in] handle of the platform instance
-    ur_device_type_t DeviceType,    ///< [in] the type of the devices.
-    uint32_t
-        NumEntries, ///< [in] the number of devices to be added to phDevices.
-    ///< If phDevices in not NULL then NumEntries should be greater than zero,
-    ///< otherwise ::UR_RESULT_ERROR_INVALID_VALUE,
-    ///< will be returned.
-    ur_device_handle_t *
-        phDevices, ///< [out][optional][range(0, NumEntries)] array of handle of devices.
-    ///< If NumEntries is less than the number of devices available, then only
-    ///< that number of devices will be retrieved.
-    uint32_t *pNumDevices ///< [out][optional] pointer to the number of devices.
-    ///< pNumDevices will be updated with the total number of selected devices
-    ///< available for the given platform.
-) {
+ur_result_t UR_APICALL
+urDeviceGetSelected(
+    ur_platform_handle_t hPlatform,                 ///< [in] handle of the platform instance
+    ur_device_type_t DeviceType,                    ///< [in] the type of the devices.
+    uint32_t NumEntries,                            ///< [in] the number of devices to be added to phDevices.
+                                                    ///< If phDevices in not NULL then NumEntries should be greater than zero,
+                                                    ///< otherwise ::UR_RESULT_ERROR_INVALID_VALUE,
+                                                    ///< will be returned.
+    ur_device_handle_t* phDevices,                  ///< [out][optional][range(0, NumEntries)] array of handle of devices.
+                                                    ///< If NumEntries is less than the number of devices available, then only
+                                                    ///< that number of devices will be retrieved.
+    uint32_t* pNumDevices                           ///< [out][optional] pointer to the number of devices.
+                                                    ///< pNumDevices will be updated with the total number of selected devices
+                                                    ///< available for the given platform.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Retrieves various information about device
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads.
 ///     - The implementation of this function should be lock-free.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clGetDeviceInfo**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -781,20 +789,20 @@ ur_result_t UR_APICALL urDeviceGetSelected(
 ///     - ::UR_RESULT_ERROR_INVALID_DEVICE
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urDeviceGetInfo(
-    ur_device_handle_t hDevice, ///< [in] handle of the device instance
-    ur_device_info_t propName,  ///< [in] type of the info to retrieve
-    size_t propSize, ///< [in] the number of bytes pointed to by pPropValue.
-    void *
-        pPropValue, ///< [out][optional][typename(propName, propSize)] array of bytes holding
-                    ///< the info.
-    ///< If propSize is not equal to or greater than the real number of bytes
-    ///< needed to return the info
-    ///< then the ::UR_RESULT_ERROR_INVALID_SIZE error is returned and
-    ///< pPropValue is not used.
-    size_t *
-        pPropSizeRet ///< [out][optional] pointer to the actual size in bytes of the queried propName.
-) {
+ur_result_t UR_APICALL
+urDeviceGetInfo(
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device instance
+    ur_device_info_t propName,                      ///< [in] type of the info to retrieve
+    size_t propSize,                                ///< [in] the number of bytes pointed to by pPropValue.
+    void* pPropValue,                               ///< [out][optional][typename(propName, propSize)] array of bytes holding
+                                                    ///< the info.
+                                                    ///< If propSize is not equal to or greater than the real number of bytes
+                                                    ///< needed to return the info
+                                                    ///< then the ::UR_RESULT_ERROR_INVALID_SIZE error is returned and
+                                                    ///< pPropValue is not used.
+    size_t* pPropSizeRet                            ///< [out][optional] pointer to the actual size in bytes of the queried propName.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -802,7 +810,7 @@ ur_result_t UR_APICALL urDeviceGetInfo(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Makes a reference of the device handle indicating it's in use until
 ///        paired ::urDeviceRelease is called
-///
+/// 
 /// @details
 ///     - Increments the device reference count if `hDevice` is a valid
 ///       sub-device created by a call to `urDevicePartition`. If `hDevice` is a
@@ -813,11 +821,11 @@ ur_result_t UR_APICALL urDeviceGetInfo(
 ///     - The application may call this function from simultaneous threads for
 ///       the same device.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clRetainDevice**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -825,17 +833,18 @@ ur_result_t UR_APICALL urDeviceGetInfo(
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE
 ///         + `NULL == hDevice`
-ur_result_t UR_APICALL urDeviceRetain(
-    ur_device_handle_t
-        hDevice ///< [in][retain] handle of the device to get a reference of.
-) {
+ur_result_t UR_APICALL
+urDeviceRetain(
+    ur_device_handle_t hDevice                      ///< [in][retain] handle of the device to get a reference of.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Releases the device handle reference indicating end of its usage
-///
+/// 
 /// @details
 ///     - Decrements the device reference count if `hDevice` is a valid
 ///       sub-device created by a call to `urDevicePartition`. If `hDevice` is a
@@ -844,11 +853,11 @@ ur_result_t UR_APICALL urDeviceRetain(
 ///     - The application may call this function from simultaneous threads for
 ///       the same device.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clReleaseDevice**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -856,17 +865,18 @@ ur_result_t UR_APICALL urDeviceRetain(
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE
 ///         + `NULL == hDevice`
-ur_result_t UR_APICALL urDeviceRelease(
-    ur_device_handle_t
-        hDevice ///< [in][release] handle of the device to release.
-) {
+ur_result_t UR_APICALL
+urDeviceRelease(
+    ur_device_handle_t hDevice                      ///< [in][release] handle of the device to release.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Partition the device into sub-devices
-///
+/// 
 /// @details
 ///     - Repeated calls to this function with the same inputs will produce the
 ///       same output in the same order.
@@ -875,11 +885,11 @@ ur_result_t UR_APICALL urDeviceRelease(
 ///     - The application may call this function from simultaneous threads for
 ///       the same device.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clCreateSubDevices**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -892,19 +902,18 @@ ur_result_t UR_APICALL urDeviceRelease(
 ///         + `NULL == pProperties->pProperties`
 ///     - ::UR_RESULT_ERROR_DEVICE_PARTITION_FAILED
 ///     - ::UR_RESULT_ERROR_INVALID_DEVICE_PARTITION_COUNT
-ur_result_t UR_APICALL urDevicePartition(
-    ur_device_handle_t hDevice, ///< [in] handle of the device to partition.
-    const ur_device_partition_properties_t
-        *pProperties,    ///< [in] Device partition properties.
-    uint32_t NumDevices, ///< [in] the number of sub-devices.
-    ur_device_handle_t *
-        phSubDevices, ///< [out][optional][range(0, NumDevices)] array of handle of devices.
-    ///< If NumDevices is less than the number of sub-devices available, then
-    ///< the function shall only retrieve that number of sub-devices.
-    uint32_t *
-        pNumDevicesRet ///< [out][optional] pointer to the number of sub-devices the device can be
-    ///< partitioned into according to the partitioning property.
-) {
+ur_result_t UR_APICALL
+urDevicePartition(
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device to partition.
+    const ur_device_partition_properties_t* pProperties,///< [in] Device partition properties.
+    uint32_t NumDevices,                            ///< [in] the number of sub-devices.
+    ur_device_handle_t* phSubDevices,               ///< [out][optional][range(0, NumDevices)] array of handle of devices.
+                                                    ///< If NumDevices is less than the number of sub-devices available, then
+                                                    ///< the function shall only retrieve that number of sub-devices.
+    uint32_t* pNumDevicesRet                        ///< [out][optional] pointer to the number of sub-devices the device can be
+                                                    ///< partitioned into according to the partitioning property.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -912,7 +921,7 @@ ur_result_t UR_APICALL urDevicePartition(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Selects the most appropriate device binary based on runtime
 ///        information and the IR characteristics.
-///
+/// 
 /// @details
 ///     - The input binaries are various AOT images, and possibly an IL binary
 ///       for JIT compilation.
@@ -922,7 +931,7 @@ ur_result_t UR_APICALL urDevicePartition(
 ///     - The application may call this function from simultaneous threads for
 ///       the same device.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -935,25 +944,24 @@ ur_result_t UR_APICALL urDevicePartition(
 ///         + `NULL == pSelectedBinary`
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         + `NumBinaries == 0`
-ur_result_t UR_APICALL urDeviceSelectBinary(
-    ur_device_handle_t
-        hDevice, ///< [in] handle of the device to select binary for.
-    const ur_device_binary_t
-        *pBinaries,       ///< [in] the array of binaries to select from.
-    uint32_t NumBinaries, ///< [in] the number of binaries passed in ppBinaries.
-                          ///< Must greater than or equal to zero otherwise
-                          ///< ::UR_RESULT_ERROR_INVALID_VALUE is returned.
-    uint32_t *
-        pSelectedBinary ///< [out] the index of the selected binary in the input array of binaries.
-    ///< If a suitable binary was not found the function returns ::UR_RESULT_ERROR_INVALID_BINARY.
-) {
+ur_result_t UR_APICALL
+urDeviceSelectBinary(
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device to select binary for.
+    const ur_device_binary_t* pBinaries,            ///< [in] the array of binaries to select from.
+    uint32_t NumBinaries,                           ///< [in] the number of binaries passed in ppBinaries.
+                                                    ///< Must greater than or equal to zero otherwise
+                                                    ///< ::UR_RESULT_ERROR_INVALID_VALUE is returned.
+    uint32_t* pSelectedBinary                       ///< [out] the index of the selected binary in the input array of binaries.
+                                                    ///< If a suitable binary was not found the function returns ::UR_RESULT_ERROR_INVALID_BINARY.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Return platform native device handle.
-///
+/// 
 /// @details
 ///     - Retrieved native handle can be used for direct interaction with the
 ///       native platform driver.
@@ -962,7 +970,7 @@ ur_result_t UR_APICALL urDeviceSelectBinary(
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -974,24 +982,25 @@ ur_result_t UR_APICALL urDeviceSelectBinary(
 ///         + `NULL == phNativeDevice`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 ///         + If the adapter has no underlying equivalent handle.
-ur_result_t UR_APICALL urDeviceGetNativeHandle(
-    ur_device_handle_t hDevice, ///< [in] handle of the device.
-    ur_native_handle_t
-        *phNativeDevice ///< [out] a pointer to the native handle of the device.
-) {
+ur_result_t UR_APICALL
+urDeviceGetNativeHandle(
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device.
+    ur_native_handle_t* phNativeDevice              ///< [out] a pointer to the native handle of the device.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create runtime device object from native device handle.
-///
+/// 
 /// @details
 ///     - Creates runtime device handle from native driver device handle.
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1003,32 +1012,30 @@ ur_result_t UR_APICALL urDeviceGetNativeHandle(
 ///         + `NULL == phDevice`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 ///         + If the adapter has no underlying equivalent handle.
-ur_result_t UR_APICALL urDeviceCreateWithNativeHandle(
-    ur_native_handle_t
-        hNativeDevice, ///< [in][nocheck] the native handle of the device.
-    ur_adapter_handle_t
-        hAdapter, ///< [in] handle of the adapter to which `hNativeDevice` belongs
-    const ur_device_native_properties_t *
-        pProperties, ///< [in][optional] pointer to native device properties struct.
-    ur_device_handle_t
-        *phDevice ///< [out] pointer to the handle of the device object created.
-) {
+ur_result_t UR_APICALL
+urDeviceCreateWithNativeHandle(
+    ur_native_handle_t hNativeDevice,               ///< [in][nocheck] the native handle of the device.
+    ur_adapter_handle_t hAdapter,                   ///< [in] handle of the adapter to which `hNativeDevice` belongs
+    const ur_device_native_properties_t* pProperties,   ///< [in][optional] pointer to native device properties struct.
+    ur_device_handle_t* phDevice                    ///< [out] pointer to the handle of the device object created.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Returns synchronized Host and Device global timestamps.
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clGetDeviceAndHostTimer**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1036,22 +1043,22 @@ ur_result_t UR_APICALL urDeviceCreateWithNativeHandle(
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE
 ///         + `NULL == hDevice`
-ur_result_t UR_APICALL urDeviceGetGlobalTimestamps(
-    ur_device_handle_t hDevice, ///< [in] handle of the device instance
-    uint64_t *
-        pDeviceTimestamp, ///< [out][optional] pointer to the Device's global timestamp that
-                          ///< correlates with the Host's global timestamp value
-    uint64_t *
-        pHostTimestamp ///< [out][optional] pointer to the Host's global timestamp that
-                       ///< correlates with the Device's global timestamp value
-) {
+ur_result_t UR_APICALL
+urDeviceGetGlobalTimestamps(
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device instance
+    uint64_t* pDeviceTimestamp,                     ///< [out][optional] pointer to the Device's global timestamp that
+                                                    ///< correlates with the Host's global timestamp value
+    uint64_t* pHostTimestamp                        ///< [out][optional] pointer to the Host's global timestamp that
+                                                    ///< correlates with the Device's global timestamp value
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Creates a context with the given devices.
-///
+/// 
 /// @details
 ///     - All devices should be from the same platform.
 ///     - Context is used for resource sharing between all the devices
@@ -1062,11 +1069,11 @@ ur_result_t UR_APICALL urDeviceGetGlobalTimestamps(
 ///       subsequent call to ::urContextRelease.
 ///     - The application may call this function from simultaneous threads.
 ///     - The implementation of this function must be thread-safe.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clCreateContext**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1079,15 +1086,14 @@ ur_result_t UR_APICALL urDeviceGetGlobalTimestamps(
 ///         + `NULL != pProperties && ::UR_CONTEXT_FLAGS_MASK & pProperties->flags`
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
-ur_result_t UR_APICALL urContextCreate(
-    uint32_t DeviceCount, ///< [in] the number of devices given in phDevices
-    const ur_device_handle_t
-        *phDevices, ///< [in][range(0, DeviceCount)] array of handle of devices.
-    const ur_context_properties_t *
-        pProperties, ///< [in][optional] pointer to context creation properties.
-    ur_context_handle_t
-        *phContext ///< [out] pointer to handle of context object created
-) {
+ur_result_t UR_APICALL
+urContextCreate(
+    uint32_t DeviceCount,                           ///< [in] the number of devices given in phDevices
+    const ur_device_handle_t* phDevices,            ///< [in][range(0, DeviceCount)] array of handle of devices.
+    const ur_context_properties_t* pProperties,     ///< [in][optional] pointer to context creation properties.
+    ur_context_handle_t* phContext                  ///< [out] pointer to handle of context object created
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -1095,18 +1101,18 @@ ur_result_t UR_APICALL urContextCreate(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Makes a reference of the context handle indicating it's in use until
 ///        paired ::urContextRelease is called
-///
+/// 
 /// @details
 ///     - It is not valid to use a context handle, which has all of its
 ///       references released.
 ///     - The application may call this function from simultaneous threads for
 ///       the same device.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clRetainContext**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1114,26 +1120,27 @@ ur_result_t UR_APICALL urContextCreate(
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE
 ///         + `NULL == hContext`
-ur_result_t UR_APICALL urContextRetain(
-    ur_context_handle_t
-        hContext ///< [in][retain] handle of the context to get a reference of.
-) {
+ur_result_t UR_APICALL
+urContextRetain(
+    ur_context_handle_t hContext                    ///< [in][retain] handle of the context to get a reference of.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Releases the context handle reference indicating end of its usage
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clReleaseContext**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1141,25 +1148,26 @@ ur_result_t UR_APICALL urContextRetain(
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE
 ///         + `NULL == hContext`
-ur_result_t UR_APICALL urContextRelease(
-    ur_context_handle_t
-        hContext ///< [in][release] handle of the context to release.
-) {
+ur_result_t UR_APICALL
+urContextRelease(
+    ur_context_handle_t hContext                    ///< [in][release] handle of the context to release.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Retrieves various information about context
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads.
 ///     - The implementation of this function should be lock-free.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clGetContextInfo**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1180,28 +1188,27 @@ ur_result_t UR_APICALL urContextRelease(
 ///     - ::UR_RESULT_ERROR_INVALID_CONTEXT
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urContextGetInfo(
-    ur_context_handle_t hContext, ///< [in] handle of the context
-    ur_context_info_t propName,   ///< [in] type of the info to retrieve
-    size_t
-        propSize, ///< [in] the number of bytes of memory pointed to by pPropValue.
-    void *
-        pPropValue, ///< [out][optional][typename(propName, propSize)] array of bytes holding
-                    ///< the info.
-    ///< if propSize is not equal to or greater than the real number of bytes
-    ///< needed to return
-    ///< the info then the ::UR_RESULT_ERROR_INVALID_SIZE error is returned and
-    ///< pPropValue is not used.
-    size_t *
-        pPropSizeRet ///< [out][optional] pointer to the actual size in bytes of the queried propName.
-) {
+ur_result_t UR_APICALL
+urContextGetInfo(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context
+    ur_context_info_t propName,                     ///< [in] type of the info to retrieve
+    size_t propSize,                                ///< [in] the number of bytes of memory pointed to by pPropValue.
+    void* pPropValue,                               ///< [out][optional][typename(propName, propSize)] array of bytes holding
+                                                    ///< the info.
+                                                    ///< if propSize is not equal to or greater than the real number of bytes
+                                                    ///< needed to return
+                                                    ///< the info then the ::UR_RESULT_ERROR_INVALID_SIZE error is returned and
+                                                    ///< pPropValue is not used.
+    size_t* pPropSizeRet                            ///< [out][optional] pointer to the actual size in bytes of the queried propName.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Return platform native context handle.
-///
+/// 
 /// @details
 ///     - Retrieved native handle can be used for direct interaction with the
 ///       native platform driver.
@@ -1210,7 +1217,7 @@ ur_result_t UR_APICALL urContextGetInfo(
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1222,24 +1229,25 @@ ur_result_t UR_APICALL urContextGetInfo(
 ///         + `NULL == phNativeContext`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 ///         + If the adapter has no underlying equivalent handle.
-ur_result_t UR_APICALL urContextGetNativeHandle(
-    ur_context_handle_t hContext, ///< [in] handle of the context.
-    ur_native_handle_t *
-        phNativeContext ///< [out] a pointer to the native handle of the context.
-) {
+ur_result_t UR_APICALL
+urContextGetNativeHandle(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context.
+    ur_native_handle_t* phNativeContext             ///< [out] a pointer to the native handle of the context.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create runtime context object from native context handle.
-///
+/// 
 /// @details
 ///     - Creates runtime context handle from native driver context handle.
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1251,27 +1259,24 @@ ur_result_t UR_APICALL urContextGetNativeHandle(
 ///         + `NULL == phContext`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 ///         + If the adapter has no underlying equivalent handle.
-ur_result_t UR_APICALL urContextCreateWithNativeHandle(
-    ur_native_handle_t
-        hNativeContext, ///< [in][nocheck] the native handle of the context.
-    ur_adapter_handle_t
-        hAdapter, ///< [in] handle of the adapter that owns the native handle
-    uint32_t numDevices, ///< [in] number of devices associated with the context
-    const ur_device_handle_t *
-        phDevices, ///< [in][optional][range(0, numDevices)] list of devices associated with
-                   ///< the context
-    const ur_context_native_properties_t *
-        pProperties, ///< [in][optional] pointer to native context properties struct
-    ur_context_handle_t *
-        phContext ///< [out] pointer to the handle of the context object created.
-) {
+ur_result_t UR_APICALL
+urContextCreateWithNativeHandle(
+    ur_native_handle_t hNativeContext,              ///< [in][nocheck] the native handle of the context.
+    ur_adapter_handle_t hAdapter,                   ///< [in] handle of the adapter that owns the native handle
+    uint32_t numDevices,                            ///< [in] number of devices associated with the context
+    const ur_device_handle_t* phDevices,            ///< [in][optional][range(0, numDevices)] list of devices associated with
+                                                    ///< the context
+    const ur_context_native_properties_t* pProperties,  ///< [in][optional] pointer to native context properties struct
+    ur_context_handle_t* phContext                  ///< [out] pointer to the handle of the context object created.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Call extended deleter function as callback.
-///
+/// 
 /// @details
 ///     - Calls extended deleter, a user-defined callback to delete context on
 ///       some platforms.
@@ -1281,7 +1286,7 @@ ur_result_t UR_APICALL urContextCreateWithNativeHandle(
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1291,20 +1296,20 @@ ur_result_t UR_APICALL urContextCreateWithNativeHandle(
 ///         + `NULL == hContext`
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_POINTER
 ///         + `NULL == pfnDeleter`
-ur_result_t UR_APICALL urContextSetExtendedDeleter(
-    ur_context_handle_t hContext, ///< [in] handle of the context.
-    ur_context_extended_deleter_t
-        pfnDeleter, ///< [in] Function pointer to extended deleter.
-    void *
-        pUserData ///< [in][out][optional] pointer to data to be passed to callback.
-) {
+ur_result_t UR_APICALL
+urContextSetExtendedDeleter(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context.
+    ur_context_extended_deleter_t pfnDeleter,       ///< [in] Function pointer to extended deleter.
+    void* pUserData                                 ///< [in][out][optional] pointer to data to be passed to callback.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create an image object
-///
+/// 
 /// @details
 ///     - The primary ::ur_image_format_t that must be supported by all the
 ///       adapters are {UR_IMAGE_CHANNEL_ORDER_RGBA, UR_IMAGE_CHANNEL_TYPE_UNORM_INT8},
@@ -1319,11 +1324,11 @@ ur_result_t UR_APICALL urContextSetExtendedDeleter(
 ///       {UR_IMAGE_CHANNEL_ORDER_RGBA, UR_IMAGE_CHANNEL_TYPE_UNSIGNED_INT32},
 ///       {UR_IMAGE_CHANNEL_ORDER_RGBA, UR_IMAGE_CHANNEL_TYPE_HALF_FLOAT},
 ///       {UR_IMAGE_CHANNEL_ORDER_RGBA, UR_IMAGE_CHANNEL_TYPE_FLOAT}.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clCreateImage**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1353,30 +1358,31 @@ ur_result_t UR_APICALL urContextSetExtendedDeleter(
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_IMAGE_FORMAT
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urMemImageCreate(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_mem_flags_t flags, ///< [in] allocation and usage information flags
-    const ur_image_format_t
-        *pImageFormat, ///< [in] pointer to image format specification
-    const ur_image_desc_t *pImageDesc, ///< [in] pointer to image description
-    void *pHost,           ///< [in][optional] pointer to the buffer data
-    ur_mem_handle_t *phMem ///< [out] pointer to handle of image object created
-) {
+ur_result_t UR_APICALL
+urMemImageCreate(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_mem_flags_t flags,                           ///< [in] allocation and usage information flags
+    const ur_image_format_t* pImageFormat,          ///< [in] pointer to image format specification
+    const ur_image_desc_t* pImageDesc,              ///< [in] pointer to image description
+    void* pHost,                                    ///< [in][optional] pointer to the buffer data
+    ur_mem_handle_t* phMem                          ///< [out] pointer to handle of image object created
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create a memory buffer
-///
+/// 
 /// @details
 ///     - See also ::ur_buffer_channel_properties_t.
 ///     - See also ::ur_buffer_alloc_location_properties_t.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clCreateBuffer**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1398,15 +1404,15 @@ ur_result_t UR_APICALL urMemImageCreate(
 ///         + `pProperties != NULL && pProperties->pHost != NULL && (flags & (UR_MEM_FLAG_USE_HOST_POINTER | UR_MEM_FLAG_ALLOC_COPY_HOST_POINTER)) == 0`
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urMemBufferCreate(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_mem_flags_t flags, ///< [in] allocation and usage information flags
-    size_t size, ///< [in] size in bytes of the memory object to be allocated
-    const ur_buffer_properties_t
-        *pProperties, ///< [in][optional] pointer to buffer creation properties
-    ur_mem_handle_t
-        *phBuffer ///< [out] pointer to handle of the memory buffer created
-) {
+ur_result_t UR_APICALL
+urMemBufferCreate(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_mem_flags_t flags,                           ///< [in] allocation and usage information flags
+    size_t size,                                    ///< [in] size in bytes of the memory object to be allocated
+    const ur_buffer_properties_t* pProperties,      ///< [in][optional] pointer to buffer creation properties
+    ur_mem_handle_t* phBuffer                       ///< [out] pointer to handle of the memory buffer created
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -1414,15 +1420,15 @@ ur_result_t UR_APICALL urMemBufferCreate(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Get a reference the memory object. Increment the memory object's
 ///        reference count
-///
+/// 
 /// @details
 ///     - Useful in library function to retain access to the memory object after
 ///       the caller released the object
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clRetainMemoryObject**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1433,10 +1439,11 @@ ur_result_t UR_APICALL urMemBufferCreate(
 ///     - ::UR_RESULT_ERROR_INVALID_MEM_OBJECT
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urMemRetain(
-    ur_mem_handle_t
-        hMem ///< [in][retain] handle of the memory object to get access
-) {
+ur_result_t UR_APICALL
+urMemRetain(
+    ur_mem_handle_t hMem                            ///< [in][retain] handle of the memory object to get access
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -1444,11 +1451,11 @@ ur_result_t UR_APICALL urMemRetain(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Decrement the memory object's reference count and delete the object if
 ///        the reference count becomes zero.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clReleaseMemoryObject**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1458,21 +1465,22 @@ ur_result_t UR_APICALL urMemRetain(
 ///         + `NULL == hMem`
 ///     - ::UR_RESULT_ERROR_INVALID_MEM_OBJECT
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urMemRelease(
-    ur_mem_handle_t
-        hMem ///< [in][release] handle of the memory object to release
-) {
+ur_result_t UR_APICALL
+urMemRelease(
+    ur_mem_handle_t hMem                            ///< [in][release] handle of the memory object to release
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create a sub buffer representing a region in an existing buffer
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clCreateSubBuffer**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1495,23 +1503,22 @@ ur_result_t UR_APICALL urMemRelease(
 ///     - ::UR_RESULT_ERROR_INVALID_HOST_PTR
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urMemBufferPartition(
-    ur_mem_handle_t
-        hBuffer,          ///< [in] handle of the buffer object to allocate from
-    ur_mem_flags_t flags, ///< [in] allocation and usage information flags
-    ur_buffer_create_type_t bufferCreateType, ///< [in] buffer creation type
-    const ur_buffer_region_t
-        *pRegion, ///< [in] pointer to buffer create region information
-    ur_mem_handle_t
-        *phMem ///< [out] pointer to the handle of sub buffer created
-) {
+ur_result_t UR_APICALL
+urMemBufferPartition(
+    ur_mem_handle_t hBuffer,                        ///< [in] handle of the buffer object to allocate from
+    ur_mem_flags_t flags,                           ///< [in] allocation and usage information flags
+    ur_buffer_create_type_t bufferCreateType,       ///< [in] buffer creation type
+    const ur_buffer_region_t* pRegion,              ///< [in] pointer to buffer create region information
+    ur_mem_handle_t* phMem                          ///< [out] pointer to the handle of sub buffer created
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Return platform native mem handle.
-///
+/// 
 /// @details
 ///     - Retrieved native handle can be used for direct interaction with the
 ///       native platform driver.
@@ -1522,7 +1529,7 @@ ur_result_t UR_APICALL urMemBufferPartition(
 ///     - The implementation of this function should be thread-safe.
 ///     - The implementation may require a valid device handle to return the
 ///       native mem handle
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1535,26 +1542,26 @@ ur_result_t UR_APICALL urMemBufferPartition(
 ///         + `NULL == phNativeMem`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 ///         + If the adapter has no underlying equivalent handle.
-ur_result_t UR_APICALL urMemGetNativeHandle(
-    ur_mem_handle_t hMem, ///< [in] handle of the mem.
-    ur_device_handle_t
-        hDevice, ///< [in][optional] handle of the device that the native handle will be
-                 ///< resident on.
-    ur_native_handle_t
-        *phNativeMem ///< [out] a pointer to the native handle of the mem.
-) {
+ur_result_t UR_APICALL
+urMemGetNativeHandle(
+    ur_mem_handle_t hMem,                           ///< [in] handle of the mem.
+    ur_device_handle_t hDevice,                     ///< [in][optional] handle of the device that the native handle will be
+                                                    ///< resident on.
+    ur_native_handle_t* phNativeMem                 ///< [out] a pointer to the native handle of the mem.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create runtime buffer memory object from native memory handle.
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1566,27 +1573,26 @@ ur_result_t UR_APICALL urMemGetNativeHandle(
 ///         + `NULL == phMem`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 ///         + If the adapter has no underlying equivalent handle.
-ur_result_t UR_APICALL urMemBufferCreateWithNativeHandle(
-    ur_native_handle_t
-        hNativeMem, ///< [in][nocheck] the native handle to the memory.
-    ur_context_handle_t hContext, ///< [in] handle of the context object.
-    const ur_mem_native_properties_t *
-        pProperties, ///< [in][optional] pointer to native memory creation properties.
-    ur_mem_handle_t
-        *phMem ///< [out] pointer to handle of buffer memory object created.
-) {
+ur_result_t UR_APICALL
+urMemBufferCreateWithNativeHandle(
+    ur_native_handle_t hNativeMem,                  ///< [in][nocheck] the native handle to the memory.
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object.
+    const ur_mem_native_properties_t* pProperties,  ///< [in][optional] pointer to native memory creation properties.
+    ur_mem_handle_t* phMem                          ///< [out] pointer to handle of buffer memory object created.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create runtime image memory object from native memory handle.
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1600,32 +1606,30 @@ ur_result_t UR_APICALL urMemBufferCreateWithNativeHandle(
 ///         + `NULL == phMem`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 ///         + If the adapter has no underlying equivalent handle.
-ur_result_t UR_APICALL urMemImageCreateWithNativeHandle(
-    ur_native_handle_t
-        hNativeMem, ///< [in][nocheck] the native handle to the memory.
-    ur_context_handle_t hContext, ///< [in] handle of the context object.
-    const ur_image_format_t
-        *pImageFormat, ///< [in] pointer to image format specification.
-    const ur_image_desc_t *pImageDesc, ///< [in] pointer to image description.
-    const ur_mem_native_properties_t *
-        pProperties, ///< [in][optional] pointer to native memory creation properties.
-    ur_mem_handle_t
-        *phMem ///< [out] pointer to handle of image memory object created.
-) {
+ur_result_t UR_APICALL
+urMemImageCreateWithNativeHandle(
+    ur_native_handle_t hNativeMem,                  ///< [in][nocheck] the native handle to the memory.
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object.
+    const ur_image_format_t* pImageFormat,          ///< [in] pointer to image format specification.
+    const ur_image_desc_t* pImageDesc,              ///< [in] pointer to image description.
+    const ur_mem_native_properties_t* pProperties,  ///< [in][optional] pointer to native memory creation properties.
+    ur_mem_handle_t* phMem                          ///< [out] pointer to handle of image memory object created.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Retrieve information about a memory object.
-///
+/// 
 /// @details
 ///     - Query information that is common to all memory objects.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clGetMemObjectInfo**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1646,35 +1650,33 @@ ur_result_t UR_APICALL urMemImageCreateWithNativeHandle(
 ///     - ::UR_RESULT_ERROR_INVALID_MEM_OBJECT
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urMemGetInfo(
-    ur_mem_handle_t
-        hMemory,            ///< [in] handle to the memory object being queried.
-    ur_mem_info_t propName, ///< [in] type of the info to retrieve.
-    size_t
-        propSize, ///< [in] the number of bytes of memory pointed to by pPropValue.
-    void *
-        pPropValue, ///< [out][optional][typename(propName, propSize)] array of bytes holding
-                    ///< the info.
-    ///< If propSize is less than the real number of bytes needed to return
-    ///< the info then the ::UR_RESULT_ERROR_INVALID_SIZE error is returned and
-    ///< pPropValue is not used.
-    size_t *
-        pPropSizeRet ///< [out][optional] pointer to the actual size in bytes of the queried propName.
-) {
+ur_result_t UR_APICALL
+urMemGetInfo(
+    ur_mem_handle_t hMemory,                        ///< [in] handle to the memory object being queried.
+    ur_mem_info_t propName,                         ///< [in] type of the info to retrieve.
+    size_t propSize,                                ///< [in] the number of bytes of memory pointed to by pPropValue.
+    void* pPropValue,                               ///< [out][optional][typename(propName, propSize)] array of bytes holding
+                                                    ///< the info.
+                                                    ///< If propSize is less than the real number of bytes needed to return
+                                                    ///< the info then the ::UR_RESULT_ERROR_INVALID_SIZE error is returned and
+                                                    ///< pPropValue is not used.
+    size_t* pPropSizeRet                            ///< [out][optional] pointer to the actual size in bytes of the queried propName.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Retrieve information about an image object.
-///
+/// 
 /// @details
 ///     - Query information specific to an image object.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clGetImageInfo**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1695,37 +1697,36 @@ ur_result_t UR_APICALL urMemGetInfo(
 ///     - ::UR_RESULT_ERROR_INVALID_MEM_OBJECT
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urMemImageGetInfo(
-    ur_mem_handle_t hMemory, ///< [in] handle to the image object being queried.
-    ur_image_info_t propName, ///< [in] type of image info to retrieve.
-    size_t
-        propSize, ///< [in] the number of bytes of memory pointer to by pPropValue.
-    void *
-        pPropValue, ///< [out][optional][typename(propName, propSize)] array of bytes holding
-                    ///< the info.
-    ///< If propSize is less than the real number of bytes needed to return
-    ///< the info then the ::UR_RESULT_ERROR_INVALID_SIZE error is returned and
-    ///< pPropValue is not used.
-    size_t *
-        pPropSizeRet ///< [out][optional] pointer to the actual size in bytes of the queried propName.
-) {
+ur_result_t UR_APICALL
+urMemImageGetInfo(
+    ur_mem_handle_t hMemory,                        ///< [in] handle to the image object being queried.
+    ur_image_info_t propName,                       ///< [in] type of image info to retrieve.
+    size_t propSize,                                ///< [in] the number of bytes of memory pointer to by pPropValue.
+    void* pPropValue,                               ///< [out][optional][typename(propName, propSize)] array of bytes holding
+                                                    ///< the info.
+                                                    ///< If propSize is less than the real number of bytes needed to return
+                                                    ///< the info then the ::UR_RESULT_ERROR_INVALID_SIZE error is returned and
+                                                    ///< pPropValue is not used.
+    size_t* pPropSizeRet                            ///< [out][optional] pointer to the actual size in bytes of the queried propName.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create a sampler object in a context
-///
+/// 
 /// @details
 ///     - The props parameter specifies a list of sampler property names and
 ///       their corresponding values.
 ///     - The list is terminated with 0. If the list is NULL, default values
 ///       will be used.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clCreateSamplerWithProperties**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1744,12 +1745,13 @@ ur_result_t UR_APICALL urMemImageGetInfo(
 ///     - ::UR_RESULT_ERROR_INVALID_OPERATION
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urSamplerCreate(
-    ur_context_handle_t hContext,   ///< [in] handle of the context object
-    const ur_sampler_desc_t *pDesc, ///< [in] pointer to the sampler description
-    ur_sampler_handle_t
-        *phSampler ///< [out] pointer to handle of sampler object created
-) {
+ur_result_t UR_APICALL
+urSamplerCreate(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    const ur_sampler_desc_t* pDesc,                 ///< [in] pointer to the sampler description
+    ur_sampler_handle_t* phSampler                  ///< [out] pointer to handle of sampler object created
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -1757,11 +1759,11 @@ ur_result_t UR_APICALL urSamplerCreate(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Get a reference to the sampler object handle. Increment its reference
 ///        count
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clRetainSampler**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1772,10 +1774,11 @@ ur_result_t UR_APICALL urSamplerCreate(
 ///     - ::UR_RESULT_ERROR_INVALID_SAMPLER
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urSamplerRetain(
-    ur_sampler_handle_t
-        hSampler ///< [in][retain] handle of the sampler object to get access
-) {
+ur_result_t UR_APICALL
+urSamplerRetain(
+    ur_sampler_handle_t hSampler                    ///< [in][retain] handle of the sampler object to get access
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -1783,11 +1786,11 @@ ur_result_t UR_APICALL urSamplerRetain(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Decrement the sampler's reference count and delete the sampler if the
 ///        reference count becomes zero.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clReleaseSampler**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1798,21 +1801,22 @@ ur_result_t UR_APICALL urSamplerRetain(
 ///     - ::UR_RESULT_ERROR_INVALID_SAMPLER
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urSamplerRelease(
-    ur_sampler_handle_t
-        hSampler ///< [in][release] handle of the sampler object to release
-) {
+ur_result_t UR_APICALL
+urSamplerRelease(
+    ur_sampler_handle_t hSampler                    ///< [in][release] handle of the sampler object to release
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Query information about a sampler object
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clGetSamplerInfo**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1833,24 +1837,23 @@ ur_result_t UR_APICALL urSamplerRelease(
 ///     - ::UR_RESULT_ERROR_INVALID_SAMPLER
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urSamplerGetInfo(
-    ur_sampler_handle_t hSampler, ///< [in] handle of the sampler object
-    ur_sampler_info_t propName, ///< [in] name of the sampler property to query
-    size_t
-        propSize, ///< [in] size in bytes of the sampler property value provided
-    void *
-        pPropValue, ///< [out][typename(propName, propSize)][optional] value of the sampler
-                    ///< property
-    size_t *
-        pPropSizeRet ///< [out][optional] size in bytes returned in sampler property value
-) {
+ur_result_t UR_APICALL
+urSamplerGetInfo(
+    ur_sampler_handle_t hSampler,                   ///< [in] handle of the sampler object
+    ur_sampler_info_t propName,                     ///< [in] name of the sampler property to query
+    size_t propSize,                                ///< [in] size in bytes of the sampler property value provided
+    void* pPropValue,                               ///< [out][typename(propName, propSize)][optional] value of the sampler
+                                                    ///< property
+    size_t* pPropSizeRet                            ///< [out][optional] size in bytes returned in sampler property value
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Return sampler native sampler handle.
-///
+/// 
 /// @details
 ///     - Retrieved native handle can be used for direct interaction with the
 ///       native platform driver.
@@ -1859,7 +1862,7 @@ ur_result_t UR_APICALL urSamplerGetInfo(
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1871,24 +1874,25 @@ ur_result_t UR_APICALL urSamplerGetInfo(
 ///         + `NULL == phNativeSampler`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 ///         + If the adapter has no underlying equivalent handle.
-ur_result_t UR_APICALL urSamplerGetNativeHandle(
-    ur_sampler_handle_t hSampler, ///< [in] handle of the sampler.
-    ur_native_handle_t *
-        phNativeSampler ///< [out] a pointer to the native handle of the sampler.
-) {
+ur_result_t UR_APICALL
+urSamplerGetNativeHandle(
+    ur_sampler_handle_t hSampler,                   ///< [in] handle of the sampler.
+    ur_native_handle_t* phNativeSampler             ///< [out] a pointer to the native handle of the sampler.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create runtime sampler object from native sampler handle.
-///
+/// 
 /// @details
 ///     - Creates runtime sampler handle from native driver sampler handle.
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1900,22 +1904,21 @@ ur_result_t UR_APICALL urSamplerGetNativeHandle(
 ///         + `NULL == phSampler`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 ///         + If the adapter has no underlying equivalent handle.
-ur_result_t UR_APICALL urSamplerCreateWithNativeHandle(
-    ur_native_handle_t
-        hNativeSampler, ///< [in][nocheck] the native handle of the sampler.
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    const ur_sampler_native_properties_t *
-        pProperties, ///< [in][optional] pointer to native sampler properties struct.
-    ur_sampler_handle_t *
-        phSampler ///< [out] pointer to the handle of the sampler object created.
-) {
+ur_result_t UR_APICALL
+urSamplerCreateWithNativeHandle(
+    ur_native_handle_t hNativeSampler,              ///< [in][nocheck] the native handle of the sampler.
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    const ur_sampler_native_properties_t* pProperties,  ///< [in][optional] pointer to native sampler properties struct.
+    ur_sampler_handle_t* phSampler                  ///< [out] pointer to the handle of the sampler object created.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief USM allocate host memory
-///
+/// 
 /// @details
 ///     - This function must support memory pooling.
 ///     - If pUSMDesc is not NULL and pUSMDesc->pool is not NULL the allocation
@@ -1927,7 +1930,7 @@ ur_result_t UR_APICALL urSamplerCreateWithNativeHandle(
 ///       allocation.
 ///     - See also ::ur_usm_host_desc_t.
 ///     - See also ::ur_usm_alloc_location_desc_t.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -1950,23 +1953,22 @@ ur_result_t UR_APICALL urSamplerCreateWithNativeHandle(
 ///         + `size` is greater than ::UR_DEVICE_INFO_MAX_MEM_ALLOC_SIZE.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urUSMHostAlloc(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    const ur_usm_desc_t
-        *pUSMDesc, ///< [in][optional] USM memory allocation descriptor
-    ur_usm_pool_handle_t
-        pool, ///< [in][optional] Pointer to a pool created using urUSMPoolCreate
-    size_t
-        size, ///< [in] minimum size in bytes of the USM memory object to be allocated
-    void **ppMem ///< [out] pointer to USM host memory object
-) {
+ur_result_t UR_APICALL
+urUSMHostAlloc(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    const ur_usm_desc_t* pUSMDesc,                  ///< [in][optional] USM memory allocation descriptor
+    ur_usm_pool_handle_t pool,                      ///< [in][optional] Pointer to a pool created using urUSMPoolCreate
+    size_t size,                                    ///< [in] minimum size in bytes of the USM memory object to be allocated
+    void** ppMem                                    ///< [out] pointer to USM host memory object
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief USM allocate device memory
-///
+/// 
 /// @details
 ///     - This function must support memory pooling.
 ///     - If pUSMDesc is not NULL and pUSMDesc->pool is not NULL the allocation
@@ -1978,7 +1980,7 @@ ur_result_t UR_APICALL urUSMHostAlloc(
 ///       allocation.
 ///     - See also ::ur_usm_device_desc_t.
 ///     - See also ::ur_usm_alloc_location_desc_t.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2002,24 +2004,23 @@ ur_result_t UR_APICALL urUSMHostAlloc(
 ///         + `size` is greater than ::UR_DEVICE_INFO_MAX_MEM_ALLOC_SIZE.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urUSMDeviceAlloc(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_device_handle_t hDevice,   ///< [in] handle of the device object
-    const ur_usm_desc_t
-        *pUSMDesc, ///< [in][optional] USM memory allocation descriptor
-    ur_usm_pool_handle_t
-        pool, ///< [in][optional] Pointer to a pool created using urUSMPoolCreate
-    size_t
-        size, ///< [in] minimum size in bytes of the USM memory object to be allocated
-    void **ppMem ///< [out] pointer to USM device memory object
-) {
+ur_result_t UR_APICALL
+urUSMDeviceAlloc(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device object
+    const ur_usm_desc_t* pUSMDesc,                  ///< [in][optional] USM memory allocation descriptor
+    ur_usm_pool_handle_t pool,                      ///< [in][optional] Pointer to a pool created using urUSMPoolCreate
+    size_t size,                                    ///< [in] minimum size in bytes of the USM memory object to be allocated
+    void** ppMem                                    ///< [out] pointer to USM device memory object
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief USM allocate shared memory
-///
+/// 
 /// @details
 ///     - This function must support memory pooling.
 ///     - If pUSMDesc is not NULL and pUSMDesc->pool is not NULL the allocation
@@ -2032,7 +2033,7 @@ ur_result_t UR_APICALL urUSMDeviceAlloc(
 ///     - See also ::ur_usm_host_desc_t.
 ///     - See also ::ur_usm_device_desc_t.
 ///     - See also ::ur_usm_alloc_location_desc_t.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2056,24 +2057,23 @@ ur_result_t UR_APICALL urUSMDeviceAlloc(
 ///         + If `UR_DEVICE_INFO_USM_SINGLE_SHARED_SUPPORT` and `UR_DEVICE_INFO_USM_CROSS_SHARED_SUPPORT` are both false.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urUSMSharedAlloc(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_device_handle_t hDevice,   ///< [in] handle of the device object
-    const ur_usm_desc_t *
-        pUSMDesc, ///< [in][optional] Pointer to USM memory allocation descriptor.
-    ur_usm_pool_handle_t
-        pool, ///< [in][optional] Pointer to a pool created using urUSMPoolCreate
-    size_t
-        size, ///< [in] minimum size in bytes of the USM memory object to be allocated
-    void **ppMem ///< [out] pointer to USM shared memory object
-) {
+ur_result_t UR_APICALL
+urUSMSharedAlloc(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device object
+    const ur_usm_desc_t* pUSMDesc,                  ///< [in][optional] Pointer to USM memory allocation descriptor.
+    ur_usm_pool_handle_t pool,                      ///< [in][optional] Pointer to a pool created using urUSMPoolCreate
+    size_t size,                                    ///< [in] minimum size in bytes of the USM memory object to be allocated
+    void** ppMem                                    ///< [out] pointer to USM shared memory object
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Free the USM memory object
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2085,17 +2085,19 @@ ur_result_t UR_APICALL urUSMSharedAlloc(
 ///         + `NULL == pMem`
 ///     - ::UR_RESULT_ERROR_INVALID_MEM_OBJECT
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urUSMFree(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    void *pMem                    ///< [in] pointer to USM memory object
-) {
+ur_result_t UR_APICALL
+urUSMFree(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    void* pMem                                      ///< [in] pointer to USM memory object
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Get USM memory object allocation information
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2111,31 +2113,29 @@ ur_result_t UR_APICALL urUSMFree(
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
 ///     - ::UR_RESULT_ERROR_INVALID_MEM_OBJECT
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urUSMGetMemAllocInfo(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    const void *pMem,             ///< [in] pointer to USM memory object
-    ur_usm_alloc_info_t
-        propName, ///< [in] the name of the USM allocation property to query
-    size_t
-        propSize, ///< [in] size in bytes of the USM allocation property value
-    void *
-        pPropValue, ///< [out][optional][typename(propName, propSize)] value of the USM
-                    ///< allocation property
-    size_t *
-        pPropSizeRet ///< [out][optional] bytes returned in USM allocation property
-) {
+ur_result_t UR_APICALL
+urUSMGetMemAllocInfo(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    const void* pMem,                               ///< [in] pointer to USM memory object
+    ur_usm_alloc_info_t propName,                   ///< [in] the name of the USM allocation property to query
+    size_t propSize,                                ///< [in] size in bytes of the USM allocation property value
+    void* pPropValue,                               ///< [out][optional][typename(propName, propSize)] value of the USM
+                                                    ///< allocation property
+    size_t* pPropSizeRet                            ///< [out][optional] bytes returned in USM allocation property
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create USM memory pool with desired properties.
-///
+/// 
 /// @details
 ///     - UR can create multiple instances of the pool depending on allocation
 ///       requests.
 ///     - See also ::ur_usm_pool_limits_desc_t.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2150,20 +2150,21 @@ ur_result_t UR_APICALL urUSMGetMemAllocInfo(
 ///         + `::UR_USM_POOL_FLAGS_MASK & pPoolDesc->flags`
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urUSMPoolCreate(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_usm_pool_desc_t *
-        pPoolDesc, ///< [in] pointer to USM pool descriptor. Can be chained with
-                   ///< ::ur_usm_pool_limits_desc_t
-    ur_usm_pool_handle_t *ppPool ///< [out] pointer to USM memory pool
-) {
+ur_result_t UR_APICALL
+urUSMPoolCreate(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_usm_pool_desc_t* pPoolDesc,                  ///< [in] pointer to USM pool descriptor. Can be chained with
+                                                    ///< ::ur_usm_pool_limits_desc_t
+    ur_usm_pool_handle_t* ppPool                    ///< [out] pointer to USM memory pool
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Get a reference to the pool handle. Increment its reference count
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2171,9 +2172,11 @@ ur_result_t UR_APICALL urUSMPoolCreate(
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE
 ///         + `NULL == pPool`
-ur_result_t UR_APICALL urUSMPoolRetain(
-    ur_usm_pool_handle_t pPool ///< [in][retain] pointer to USM memory pool
-) {
+ur_result_t UR_APICALL
+urUSMPoolRetain(
+    ur_usm_pool_handle_t pPool                      ///< [in][retain] pointer to USM memory pool
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -2181,13 +2184,13 @@ ur_result_t UR_APICALL urUSMPoolRetain(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Decrement the pool's reference count and delete the pool if the
 ///        reference count becomes zero.
-///
+/// 
 /// @details
 ///     - All allocation belonging to the pool must be freed prior to the the
 ///       reference count becoming zero.
 ///     - If the pool is deleted, this function returns all its reserved memory
 ///       to the driver.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2195,16 +2198,18 @@ ur_result_t UR_APICALL urUSMPoolRetain(
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE
 ///         + `NULL == pPool`
-ur_result_t UR_APICALL urUSMPoolRelease(
-    ur_usm_pool_handle_t pPool ///< [in][release] pointer to USM memory pool
-) {
+ur_result_t UR_APICALL
+urUSMPoolRelease(
+    ur_usm_pool_handle_t pPool                      ///< [in][release] pointer to USM memory pool
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Query information about a USM memory pool
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2224,16 +2229,16 @@ ur_result_t UR_APICALL urUSMPoolRelease(
 ///         + `pPropValue == NULL && pPropSizeRet == NULL`
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urUSMPoolGetInfo(
-    ur_usm_pool_handle_t hPool,  ///< [in] handle of the USM memory pool
-    ur_usm_pool_info_t propName, ///< [in] name of the pool property to query
-    size_t propSize, ///< [in] size in bytes of the pool property value provided
-    void *
-        pPropValue, ///< [out][optional][typename(propName, propSize)] value of the pool
-                    ///< property
-    size_t *
-        pPropSizeRet ///< [out][optional] size in bytes returned in pool property value
-) {
+ur_result_t UR_APICALL
+urUSMPoolGetInfo(
+    ur_usm_pool_handle_t hPool,                     ///< [in] handle of the USM memory pool
+    ur_usm_pool_info_t propName,                    ///< [in] name of the pool property to query
+    size_t propSize,                                ///< [in] size in bytes of the pool property value provided
+    void* pPropValue,                               ///< [out][optional][typename(propName, propSize)] value of the pool
+                                                    ///< property
+    size_t* pPropSizeRet                            ///< [out][optional] size in bytes returned in pool property value
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -2241,7 +2246,7 @@ ur_result_t UR_APICALL urUSMPoolGetInfo(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Get information about the minimum and recommended granularity of
 ///        physical and virtual memory.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2263,30 +2268,27 @@ ur_result_t UR_APICALL urUSMPoolGetInfo(
 ///     - ::UR_RESULT_ERROR_INVALID_CONTEXT
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urVirtualMemGranularityGetInfo(
-    ur_context_handle_t hContext, ///< [in] handle of the context object.
-    ur_device_handle_t
-        hDevice, ///< [in][optional] is the device to get the granularity from, if the
-    ///< device is null then the granularity is suitable for all devices in context.
-    ur_virtual_mem_granularity_info_t
-        propName, ///< [in] type of the info to query.
-    size_t
-        propSize, ///< [in] size in bytes of the memory pointed to by pPropValue.
-    void *
-        pPropValue, ///< [out][optional][typename(propName, propSize)] array of bytes holding
-    ///< the info. If propSize is less than the real number of bytes needed to
-    ///< return the info then the ::UR_RESULT_ERROR_INVALID_SIZE error is
-    ///< returned and pPropValue is not used.
-    size_t *
-        pPropSizeRet ///< [out][optional] pointer to the actual size in bytes of the queried propName."
-) {
+ur_result_t UR_APICALL
+urVirtualMemGranularityGetInfo(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object.
+    ur_device_handle_t hDevice,                     ///< [in][optional] is the device to get the granularity from, if the
+                                                    ///< device is null then the granularity is suitable for all devices in context.
+    ur_virtual_mem_granularity_info_t propName,     ///< [in] type of the info to query.
+    size_t propSize,                                ///< [in] size in bytes of the memory pointed to by pPropValue.
+    void* pPropValue,                               ///< [out][optional][typename(propName, propSize)] array of bytes holding
+                                                    ///< the info. If propSize is less than the real number of bytes needed to
+                                                    ///< return the info then the ::UR_RESULT_ERROR_INVALID_SIZE error is
+                                                    ///< returned and pPropValue is not used.
+    size_t* pPropSizeRet                            ///< [out][optional] pointer to the actual size in bytes of the queried propName."
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Reserve a virtual memory range.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2296,25 +2298,24 @@ ur_result_t UR_APICALL urVirtualMemGranularityGetInfo(
 ///         + `NULL == hContext`
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_POINTER
 ///         + `NULL == ppStart`
-ur_result_t UR_APICALL urVirtualMemReserve(
-    ur_context_handle_t hContext, ///< [in] handle of the context object.
-    const void *
-        pStart, ///< [in][optional] pointer to the start of the virtual memory region to
-    ///< reserve, specifying a null value causes the implementation to select a
-    ///< start address.
-    size_t
-        size, ///< [in] size in bytes of the virtual address range to reserve.
-    void **
-        ppStart ///< [out] pointer to the returned address at the start of reserved virtual
-                ///< memory range.
-) {
+ur_result_t UR_APICALL
+urVirtualMemReserve(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object.
+    const void* pStart,                             ///< [in][optional] pointer to the start of the virtual memory region to
+                                                    ///< reserve, specifying a null value causes the implementation to select a
+                                                    ///< start address.
+    size_t size,                                    ///< [in] size in bytes of the virtual address range to reserve.
+    void** ppStart                                  ///< [out] pointer to the returned address at the start of reserved virtual
+                                                    ///< memory range.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Free a virtual memory range.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2324,19 +2325,20 @@ ur_result_t UR_APICALL urVirtualMemReserve(
 ///         + `NULL == hContext`
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_POINTER
 ///         + `NULL == pStart`
-ur_result_t UR_APICALL urVirtualMemFree(
-    ur_context_handle_t hContext, ///< [in] handle of the context object.
-    const void *
-        pStart, ///< [in] pointer to the start of the virtual memory range to free.
-    size_t size ///< [in] size in bytes of the virtual memory range to free.
-) {
+ur_result_t UR_APICALL
+urVirtualMemFree(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object.
+    const void* pStart,                             ///< [in] pointer to the start of the virtual memory range to free.
+    size_t size                                     ///< [in] size in bytes of the virtual memory range to free.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Map a virtual memory range to a physical memory handle.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2349,29 +2351,27 @@ ur_result_t UR_APICALL urVirtualMemFree(
 ///         + `NULL == pStart`
 ///     - ::UR_RESULT_ERROR_INVALID_ENUMERATION
 ///         + `::UR_VIRTUAL_MEM_ACCESS_FLAGS_MASK & flags`
-ur_result_t UR_APICALL urVirtualMemMap(
-    ur_context_handle_t hContext, ///< [in] handle to the context object.
-    const void
-        *pStart, ///< [in] pointer to the start of the virtual memory range.
-    size_t size, ///< [in] size in bytes of the virtual memory range to map.
-    ur_physical_mem_handle_t
-        hPhysicalMem, ///< [in] handle of the physical memory to map pStart to.
-    size_t
-        offset, ///< [in] offset in bytes into the physical memory to map pStart to.
-    ur_virtual_mem_access_flags_t
-        flags ///< [in] access flags for the physical memory mapping.
-) {
+ur_result_t UR_APICALL
+urVirtualMemMap(
+    ur_context_handle_t hContext,                   ///< [in] handle to the context object.
+    const void* pStart,                             ///< [in] pointer to the start of the virtual memory range.
+    size_t size,                                    ///< [in] size in bytes of the virtual memory range to map.
+    ur_physical_mem_handle_t hPhysicalMem,          ///< [in] handle of the physical memory to map pStart to.
+    size_t offset,                                  ///< [in] offset in bytes into the physical memory to map pStart to.
+    ur_virtual_mem_access_flags_t flags             ///< [in] access flags for the physical memory mapping.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Unmap a virtual memory range previously mapped in a context.
-///
+/// 
 /// @details
 ///     - After a call to this function, the virtual memory range is left in a
 ///       state ready to be remapped.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2381,19 +2381,20 @@ ur_result_t UR_APICALL urVirtualMemMap(
 ///         + `NULL == hContext`
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_POINTER
 ///         + `NULL == pStart`
-ur_result_t UR_APICALL urVirtualMemUnmap(
-    ur_context_handle_t hContext, ///< [in] handle to the context object.
-    const void *
-        pStart, ///< [in] pointer to the start of the mapped virtual memory range
-    size_t size ///< [in] size in bytes of the virtual memory range.
-) {
+ur_result_t UR_APICALL
+urVirtualMemUnmap(
+    ur_context_handle_t hContext,                   ///< [in] handle to the context object.
+    const void* pStart,                             ///< [in] pointer to the start of the mapped virtual memory range
+    size_t size                                     ///< [in] size in bytes of the virtual memory range.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Set the access mode of a mapped virtual memory range.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2405,21 +2406,21 @@ ur_result_t UR_APICALL urVirtualMemUnmap(
 ///         + `NULL == pStart`
 ///     - ::UR_RESULT_ERROR_INVALID_ENUMERATION
 ///         + `::UR_VIRTUAL_MEM_ACCESS_FLAGS_MASK & flags`
-ur_result_t UR_APICALL urVirtualMemSetAccess(
-    ur_context_handle_t hContext, ///< [in] handle to the context object.
-    const void
-        *pStart, ///< [in] pointer to the start of the virtual memory range.
-    size_t size, ///< [in] size in bytes of the virtual memory range.
-    ur_virtual_mem_access_flags_t
-        flags ///< [in] access flags to set for the mapped virtual memory range.
-) {
+ur_result_t UR_APICALL
+urVirtualMemSetAccess(
+    ur_context_handle_t hContext,                   ///< [in] handle to the context object.
+    const void* pStart,                             ///< [in] pointer to the start of the virtual memory range.
+    size_t size,                                    ///< [in] size in bytes of the virtual memory range.
+    ur_virtual_mem_access_flags_t flags             ///< [in] access flags to set for the mapped virtual memory range.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Get information about a mapped virtual memory range.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2431,29 +2432,27 @@ ur_result_t UR_APICALL urVirtualMemSetAccess(
 ///         + `NULL == pStart`
 ///     - ::UR_RESULT_ERROR_INVALID_ENUMERATION
 ///         + `::UR_VIRTUAL_MEM_INFO_ACCESS_MODE < propName`
-ur_result_t UR_APICALL urVirtualMemGetInfo(
-    ur_context_handle_t hContext, ///< [in] handle to the context object.
-    const void
-        *pStart, ///< [in] pointer to the start of the virtual memory range.
-    size_t size, ///< [in] size in bytes of the virtual memory range.
-    ur_virtual_mem_info_t propName, ///< [in] type of the info to query.
-    size_t
-        propSize, ///< [in] size in bytes of the memory pointed to by pPropValue.
-    void *
-        pPropValue, ///< [out][optional][typename(propName, propSize)] array of bytes holding
-    ///< the info. If propSize is less than the real number of bytes needed to
-    ///< return the info then the ::UR_RESULT_ERROR_INVALID_SIZE error is
-    ///< returned and pPropValue is not used.
-    size_t *
-        pPropSizeRet ///< [out][optional] pointer to the actual size in bytes of the queried propName."
-) {
+ur_result_t UR_APICALL
+urVirtualMemGetInfo(
+    ur_context_handle_t hContext,                   ///< [in] handle to the context object.
+    const void* pStart,                             ///< [in] pointer to the start of the virtual memory range.
+    size_t size,                                    ///< [in] size in bytes of the virtual memory range.
+    ur_virtual_mem_info_t propName,                 ///< [in] type of the info to query.
+    size_t propSize,                                ///< [in] size in bytes of the memory pointed to by pPropValue.
+    void* pPropValue,                               ///< [out][optional][typename(propName, propSize)] array of bytes holding
+                                                    ///< the info. If propSize is less than the real number of bytes needed to
+                                                    ///< return the info then the ::UR_RESULT_ERROR_INVALID_SIZE error is
+                                                    ///< returned and pPropValue is not used.
+    size_t* pPropSizeRet                            ///< [out][optional] pointer to the actual size in bytes of the queried propName."
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create a physical memory handle that virtual memory can be mapped to.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2468,24 +2467,23 @@ ur_result_t UR_APICALL urVirtualMemGetInfo(
 ///         + `NULL == phPhysicalMem`
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         + If size is not a multiple of ::UR_VIRTUAL_MEM_GRANULARITY_INFO_MINIMUM.
-ur_result_t UR_APICALL urPhysicalMemCreate(
-    ur_context_handle_t hContext, ///< [in] handle of the context object.
-    ur_device_handle_t hDevice,   ///< [in] handle of the device object.
-    size_t
-        size, ///< [in] size in bytes of physical memory to allocate, must be a multiple
-              ///< of ::UR_VIRTUAL_MEM_GRANULARITY_INFO_MINIMUM.
-    const ur_physical_mem_properties_t *
-        pProperties, ///< [in][optional] pointer to physical memory creation properties.
-    ur_physical_mem_handle_t *
-        phPhysicalMem ///< [out] pointer to handle of physical memory object created.
-) {
+ur_result_t UR_APICALL
+urPhysicalMemCreate(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object.
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device object.
+    size_t size,                                    ///< [in] size in bytes of physical memory to allocate, must be a multiple
+                                                    ///< of ::UR_VIRTUAL_MEM_GRANULARITY_INFO_MINIMUM.
+    const ur_physical_mem_properties_t* pProperties,///< [in][optional] pointer to physical memory creation properties.
+    ur_physical_mem_handle_t* phPhysicalMem         ///< [out] pointer to handle of physical memory object created.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Retain a physical memory handle, increment its reference count.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2493,17 +2491,18 @@ ur_result_t UR_APICALL urPhysicalMemCreate(
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE
 ///         + `NULL == hPhysicalMem`
-ur_result_t UR_APICALL urPhysicalMemRetain(
-    ur_physical_mem_handle_t
-        hPhysicalMem ///< [in][retain] handle of the physical memory object to retain.
-) {
+ur_result_t UR_APICALL
+urPhysicalMemRetain(
+    ur_physical_mem_handle_t hPhysicalMem           ///< [in][retain] handle of the physical memory object to retain.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Release a physical memory handle, decrement its reference count.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2511,26 +2510,27 @@ ur_result_t UR_APICALL urPhysicalMemRetain(
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE
 ///         + `NULL == hPhysicalMem`
-ur_result_t UR_APICALL urPhysicalMemRelease(
-    ur_physical_mem_handle_t
-        hPhysicalMem ///< [in][release] handle of the physical memory object to release.
-) {
+ur_result_t UR_APICALL
+urPhysicalMemRelease(
+    ur_physical_mem_handle_t hPhysicalMem           ///< [in][release] handle of the physical memory object to release.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create a program object from input intermediate language.
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads.
 ///     - The adapter may (but is not required to) perform validation of the
 ///       provided module during this call.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clCreateProgramWithIL**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2549,22 +2549,22 @@ ur_result_t UR_APICALL urPhysicalMemRelease(
 ///         + If `pIL` is not a valid IL binary for devices in `hContext`.
 ///     - ::UR_RESULT_ERROR_COMPILER_NOT_AVAILABLE
 ///         + If devices in `hContext` don't have the capability to compile an IL binary at runtime.
-ur_result_t UR_APICALL urProgramCreateWithIL(
-    ur_context_handle_t hContext, ///< [in] handle of the context instance
-    const void *pIL,              ///< [in] pointer to IL binary.
-    size_t length,                ///< [in] length of `pIL` in bytes.
-    const ur_program_properties_t *
-        pProperties, ///< [in][optional] pointer to program creation properties.
-    ur_program_handle_t
-        *phProgram ///< [out] pointer to handle of program object created.
-) {
+ur_result_t UR_APICALL
+urProgramCreateWithIL(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context instance
+    const void* pIL,                                ///< [in] pointer to IL binary.
+    size_t length,                                  ///< [in] length of `pIL` in bytes.
+    const ur_program_properties_t* pProperties,     ///< [in][optional] pointer to program creation properties.
+    ur_program_handle_t* phProgram                  ///< [out] pointer to handle of program object created.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create a program object from device native binary.
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads.
 ///     - Following a successful call to this entry point, `phProgram` will
@@ -2574,11 +2574,11 @@ ur_result_t UR_APICALL urProgramCreateWithIL(
 ///       context.
 ///     - The adapter may (but is not required to) perform validation of the
 ///       provided module during this call.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clCreateProgramWithBinary**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2595,17 +2595,16 @@ ur_result_t UR_APICALL urProgramCreateWithIL(
 ///         + `NULL != pProperties && NULL != pProperties->pMetadatas && pProperties->count == 0`
 ///     - ::UR_RESULT_ERROR_INVALID_NATIVE_BINARY
 ///         + If `pBinary` isn't a valid binary for `hDevice.`
-ur_result_t UR_APICALL urProgramCreateWithBinary(
-    ur_context_handle_t hContext, ///< [in] handle of the context instance
-    ur_device_handle_t
-        hDevice,            ///< [in] handle to device associated with binary.
-    size_t size,            ///< [in] size in bytes.
-    const uint8_t *pBinary, ///< [in] pointer to binary.
-    const ur_program_properties_t *
-        pProperties, ///< [in][optional] pointer to program creation properties.
-    ur_program_handle_t
-        *phProgram ///< [out] pointer to handle of Program object created.
-) {
+ur_result_t UR_APICALL
+urProgramCreateWithBinary(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context instance
+    ur_device_handle_t hDevice,                     ///< [in] handle to device associated with binary.
+    size_t size,                                    ///< [in] size in bytes.
+    const uint8_t* pBinary,                         ///< [in] pointer to binary.
+    const ur_program_properties_t* pProperties,     ///< [in][optional] pointer to program creation properties.
+    ur_program_handle_t* phProgram                  ///< [out] pointer to handle of Program object created.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -2613,17 +2612,17 @@ ur_result_t UR_APICALL urProgramCreateWithBinary(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Produces an executable program from one program, negates need for the
 ///        linking step.
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads.
 ///     - Following a successful call to this entry point, the program passed
 ///       will contain a binary of the ::UR_PROGRAM_BINARY_TYPE_EXECUTABLE type
 ///       for each device in `hContext`.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clBuildProgram**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2636,29 +2635,30 @@ ur_result_t UR_APICALL urProgramCreateWithBinary(
 ///         + If `hProgram` isn't a valid program object.
 ///     - ::UR_RESULT_ERROR_PROGRAM_BUILD_FAILURE
 ///         + If an error occurred when building `hProgram`.
-ur_result_t UR_APICALL urProgramBuild(
-    ur_context_handle_t hContext, ///< [in] handle of the context instance.
-    ur_program_handle_t hProgram, ///< [in] Handle of the program to build.
-    const char *
-        pOptions ///< [in][optional] pointer to build options null-terminated string.
-) {
+ur_result_t UR_APICALL
+urProgramBuild(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context instance.
+    ur_program_handle_t hProgram,                   ///< [in] Handle of the program to build.
+    const char* pOptions                            ///< [in][optional] pointer to build options null-terminated string.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Produces an executable program from one or more programs.
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads.
 ///     - Following a successful call to this entry point `hProgram` will
 ///       contain a binary of the ::UR_PROGRAM_BINARY_TYPE_COMPILED_OBJECT type
 ///       for each device in `hContext`.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clCompileProgram**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2671,20 +2671,20 @@ ur_result_t UR_APICALL urProgramBuild(
 ///         + If `hProgram` isn't a valid program object.
 ///     - ::UR_RESULT_ERROR_PROGRAM_BUILD_FAILURE
 ///         + If an error occurred while compiling `hProgram`.
-ur_result_t UR_APICALL urProgramCompile(
-    ur_context_handle_t hContext, ///< [in] handle of the context instance.
-    ur_program_handle_t
-        hProgram, ///< [in][out] handle of the program to compile.
-    const char *
-        pOptions ///< [in][optional] pointer to build options null-terminated string.
-) {
+ur_result_t UR_APICALL
+urProgramCompile(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context instance.
+    ur_program_handle_t hProgram,                   ///< [in][out] handle of the program to compile.
+    const char* pOptions                            ///< [in][optional] pointer to build options null-terminated string.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Produces an executable program from one or more programs.
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads.
 ///     - Following a successful call to this entry point the program returned
@@ -2696,11 +2696,11 @@ ur_result_t UR_APICALL urProgramCompile(
 ///       use the build log of this program (accessible via
 ///       ::urProgramGetBuildInfo) to provide an error log for the linking
 ///       failure.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clLinkProgram**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2717,33 +2717,32 @@ ur_result_t UR_APICALL urProgramCompile(
 ///         + `count == 0`
 ///     - ::UR_RESULT_ERROR_PROGRAM_LINK_FAILURE
 ///         + If an error occurred while linking `phPrograms`.
-ur_result_t UR_APICALL urProgramLink(
-    ur_context_handle_t hContext, ///< [in] handle of the context instance.
-    uint32_t count, ///< [in] number of program handles in `phPrograms`.
-    const ur_program_handle_t *
-        phPrograms, ///< [in][range(0, count)] pointer to array of program handles.
-    const char *
-        pOptions, ///< [in][optional] pointer to linker options null-terminated string.
-    ur_program_handle_t
-        *phProgram ///< [out] pointer to handle of program object created.
-) {
+ur_result_t UR_APICALL
+urProgramLink(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context instance.
+    uint32_t count,                                 ///< [in] number of program handles in `phPrograms`.
+    const ur_program_handle_t* phPrograms,          ///< [in][range(0, count)] pointer to array of program handles.
+    const char* pOptions,                           ///< [in][optional] pointer to linker options null-terminated string.
+    ur_program_handle_t* phProgram                  ///< [out] pointer to handle of program object created.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Get a reference to the Program object.
-///
+/// 
 /// @details
 ///     - Get a reference to the Program object handle. Increment its reference
 ///       count
 ///     - The application may call this function from simultaneous threads.
 ///     - The implementation of this function should be lock-free.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clRetainProgram**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2751,27 +2750,28 @@ ur_result_t UR_APICALL urProgramLink(
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE
 ///         + `NULL == hProgram`
-ur_result_t UR_APICALL urProgramRetain(
-    ur_program_handle_t
-        hProgram ///< [in][retain] handle for the Program to retain
-) {
+ur_result_t UR_APICALL
+urProgramRetain(
+    ur_program_handle_t hProgram                    ///< [in][retain] handle for the Program to retain
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Release Program.
-///
+/// 
 /// @details
 ///     - Decrement reference count and destroy the Program if reference count
 ///       becomes zero.
 ///     - The application may call this function from simultaneous threads.
 ///     - The implementation of this function should be lock-free.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clReleaseProgram**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2779,17 +2779,18 @@ ur_result_t UR_APICALL urProgramRetain(
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE
 ///         + `NULL == hProgram`
-ur_result_t UR_APICALL urProgramRelease(
-    ur_program_handle_t
-        hProgram ///< [in][release] handle for the Program to release
-) {
+ur_result_t UR_APICALL
+urProgramRelease(
+    ur_program_handle_t hProgram                    ///< [in][release] handle for the Program to release
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Retrieves a device function pointer to a user-defined function.
-///
+/// 
 /// @details
 ///     - Retrieves a pointer to the functions with the given name and defined
 ///       in the given program.
@@ -2798,11 +2799,11 @@ ur_result_t UR_APICALL urProgramRelease(
 ///     - The application may call this function from simultaneous threads for
 ///       the same device.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clGetDeviceFunctionPointerINTEL**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2818,35 +2819,33 @@ ur_result_t UR_APICALL urProgramRelease(
 ///         + If `pFunctionName` couldn't be found in `hProgram`.
 ///     - ::UR_RESULT_ERROR_FUNCTION_ADDRESS_NOT_AVAILABLE
 ///         + If `pFunctionName` could be located, but its address couldn't be retrieved.
-ur_result_t UR_APICALL urProgramGetFunctionPointer(
-    ur_device_handle_t
-        hDevice, ///< [in] handle of the device to retrieve pointer for.
-    ur_program_handle_t
-        hProgram, ///< [in] handle of the program to search for function in.
-    ///< The program must already be built to the specified device, or
-    ///< otherwise ::UR_RESULT_ERROR_INVALID_PROGRAM_EXECUTABLE is returned.
-    const char *
-        pFunctionName, ///< [in] A null-terminates string denoting the mangled function name.
-    void **
-        ppFunctionPointer ///< [out] Returns the pointer to the function if it is found in the program.
-) {
+ur_result_t UR_APICALL
+urProgramGetFunctionPointer(
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device to retrieve pointer for.
+    ur_program_handle_t hProgram,                   ///< [in] handle of the program to search for function in.
+                                                    ///< The program must already be built to the specified device, or
+                                                    ///< otherwise ::UR_RESULT_ERROR_INVALID_PROGRAM_EXECUTABLE is returned.
+    const char* pFunctionName,                      ///< [in] A null-terminates string denoting the mangled function name.
+    void** ppFunctionPointer                        ///< [out] Returns the pointer to the function if it is found in the program.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Retrieves a pointer to a device global variable.
-///
+/// 
 /// @details
 ///     - Retrieves a pointer to a device global variable.
 ///     - The application may call this function from simultaneous threads for
 ///       the same device.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clGetDeviceGlobalVariablePointerINTEL**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2860,30 +2859,27 @@ ur_result_t UR_APICALL urProgramGetFunctionPointer(
 ///         + `NULL == ppGlobalVariablePointerRet`
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
 ///         + `name` is not a valid variable in the program.
-ur_result_t UR_APICALL urProgramGetGlobalVariablePointer(
-    ur_device_handle_t
-        hDevice, ///< [in] handle of the device to retrieve the pointer for.
-    ur_program_handle_t
-        hProgram, ///< [in] handle of the program where the global variable is.
-    const char *
-        pGlobalVariableName, ///< [in] mangled name of the global variable to retrieve the pointer for.
-    size_t *
-        pGlobalVariableSizeRet, ///< [out][optional] Returns the size of the global variable if it is found
-                                ///< in the program.
-    void **
-        ppGlobalVariablePointerRet ///< [out] Returns the pointer to the global variable if it is found in the program.
-) {
+ur_result_t UR_APICALL
+urProgramGetGlobalVariablePointer(
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device to retrieve the pointer for.
+    ur_program_handle_t hProgram,                   ///< [in] handle of the program where the global variable is.
+    const char* pGlobalVariableName,                ///< [in] mangled name of the global variable to retrieve the pointer for.
+    size_t* pGlobalVariableSizeRet,                 ///< [out][optional] Returns the size of the global variable if it is found
+                                                    ///< in the program.
+    void** ppGlobalVariablePointerRet               ///< [out] Returns the pointer to the global variable if it is found in the program.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Query information about a Program object
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clGetProgramInfo**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2904,31 +2900,31 @@ ur_result_t UR_APICALL urProgramGetGlobalVariablePointer(
 ///     - ::UR_RESULT_ERROR_INVALID_PROGRAM
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urProgramGetInfo(
-    ur_program_handle_t hProgram, ///< [in] handle of the Program object
-    ur_program_info_t propName, ///< [in] name of the Program property to query
-    size_t propSize,            ///< [in] the size of the Program property.
-    void *
-        pPropValue, ///< [in,out][optional][typename(propName, propSize)] array of bytes of
-                    ///< holding the program info property.
-    ///< If propSize is not equal to or greater than the real number of bytes
-    ///< needed to return
-    ///< the info then the ::UR_RESULT_ERROR_INVALID_SIZE error is returned and
-    ///< pPropValue is not used.
-    size_t *
-        pPropSizeRet ///< [out][optional] pointer to the actual size in bytes of the queried propName.
-) {
+ur_result_t UR_APICALL
+urProgramGetInfo(
+    ur_program_handle_t hProgram,                   ///< [in] handle of the Program object
+    ur_program_info_t propName,                     ///< [in] name of the Program property to query
+    size_t propSize,                                ///< [in] the size of the Program property.
+    void* pPropValue,                               ///< [in,out][optional][typename(propName, propSize)] array of bytes of
+                                                    ///< holding the program info property.
+                                                    ///< If propSize is not equal to or greater than the real number of bytes
+                                                    ///< needed to return
+                                                    ///< the info then the ::UR_RESULT_ERROR_INVALID_SIZE error is returned and
+                                                    ///< pPropValue is not used.
+    size_t* pPropSizeRet                            ///< [out][optional] pointer to the actual size in bytes of the queried propName.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Query build information about a Program object for a Device
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clGetProgramBuildInfo**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2939,29 +2935,28 @@ ur_result_t UR_APICALL urProgramGetInfo(
 ///         + `NULL == hDevice`
 ///     - ::UR_RESULT_ERROR_INVALID_ENUMERATION
 ///         + `::UR_PROGRAM_BUILD_INFO_BINARY_TYPE < propName`
-ur_result_t UR_APICALL urProgramGetBuildInfo(
-    ur_program_handle_t hProgram, ///< [in] handle of the Program object
-    ur_device_handle_t hDevice,   ///< [in] handle of the Device object
-    ur_program_build_info_t
-        propName,    ///< [in] name of the Program build info to query
-    size_t propSize, ///< [in] size of the Program build info property.
-    void *
-        pPropValue, ///< [in,out][optional][typename(propName, propSize)] value of the Program
-                    ///< build property.
-    ///< If propSize is not equal to or greater than the real number of bytes
-    ///< needed to return the info then the ::UR_RESULT_ERROR_INVALID_SIZE
-    ///< error is returned and pPropValue is not used.
-    size_t *
-        pPropSizeRet ///< [out][optional] pointer to the actual size in bytes of data being
-                     ///< queried by propName.
-) {
+ur_result_t UR_APICALL
+urProgramGetBuildInfo(
+    ur_program_handle_t hProgram,                   ///< [in] handle of the Program object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the Device object
+    ur_program_build_info_t propName,               ///< [in] name of the Program build info to query
+    size_t propSize,                                ///< [in] size of the Program build info property.
+    void* pPropValue,                               ///< [in,out][optional][typename(propName, propSize)] value of the Program
+                                                    ///< build property.
+                                                    ///< If propSize is not equal to or greater than the real number of bytes
+                                                    ///< needed to return the info then the ::UR_RESULT_ERROR_INVALID_SIZE
+                                                    ///< error is returned and pPropValue is not used.
+    size_t* pPropSizeRet                            ///< [out][optional] pointer to the actual size in bytes of data being
+                                                    ///< queried by propName.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Set an array of specialization constants on a Program.
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads for
 ///       the same device.
@@ -2970,7 +2965,7 @@ ur_result_t UR_APICALL urProgramGetBuildInfo(
 ///       entry point.
 ///     - Any spec constants set with this entry point will apply only to
 ///       subsequent calls to ::urProgramBuild or ::urProgramCompile.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -2987,20 +2982,21 @@ ur_result_t UR_APICALL urProgramGetBuildInfo(
 ///         + A pSpecConstant entry contains a nullptr pValue.
 ///     - ::UR_RESULT_ERROR_INVALID_SPEC_ID
 ///         + Any id specified in a pSpecConstant entry is not a valid specialization constant identifier.
-ur_result_t UR_APICALL urProgramSetSpecializationConstants(
-    ur_program_handle_t hProgram, ///< [in] handle of the Program object
-    uint32_t count, ///< [in] the number of elements in the pSpecConstants array
-    const ur_specialization_constant_info_t *
-        pSpecConstants ///< [in][range(0, count)] array of specialization constant value
-                       ///< descriptions
-) {
+ur_result_t UR_APICALL
+urProgramSetSpecializationConstants(
+    ur_program_handle_t hProgram,                   ///< [in] handle of the Program object
+    uint32_t count,                                 ///< [in] the number of elements in the pSpecConstants array
+    const ur_specialization_constant_info_t* pSpecConstants ///< [in][range(0, count)] array of specialization constant value
+                                                    ///< descriptions
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Return program native program handle.
-///
+/// 
 /// @details
 ///     - Retrieved native handle can be used for direct interaction with the
 ///       native platform driver.
@@ -3009,7 +3005,7 @@ ur_result_t UR_APICALL urProgramSetSpecializationConstants(
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3021,24 +3017,25 @@ ur_result_t UR_APICALL urProgramSetSpecializationConstants(
 ///         + `NULL == phNativeProgram`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 ///         + If the adapter has no underlying equivalent handle.
-ur_result_t UR_APICALL urProgramGetNativeHandle(
-    ur_program_handle_t hProgram, ///< [in] handle of the program.
-    ur_native_handle_t *
-        phNativeProgram ///< [out] a pointer to the native handle of the program.
-) {
+ur_result_t UR_APICALL
+urProgramGetNativeHandle(
+    ur_program_handle_t hProgram,                   ///< [in] handle of the program.
+    ur_native_handle_t* phNativeProgram             ///< [out] a pointer to the native handle of the program.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create runtime program object from native program handle.
-///
+/// 
 /// @details
 ///     - Creates runtime program handle from native driver program handle.
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3050,26 +3047,25 @@ ur_result_t UR_APICALL urProgramGetNativeHandle(
 ///         + `NULL == phProgram`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 ///         + If the adapter has no underlying equivalent handle.
-ur_result_t UR_APICALL urProgramCreateWithNativeHandle(
-    ur_native_handle_t
-        hNativeProgram, ///< [in][nocheck] the native handle of the program.
-    ur_context_handle_t hContext, ///< [in] handle of the context instance
-    const ur_program_native_properties_t *
-        pProperties, ///< [in][optional] pointer to native program properties struct.
-    ur_program_handle_t *
-        phProgram ///< [out] pointer to the handle of the program object created.
-) {
+ur_result_t UR_APICALL
+urProgramCreateWithNativeHandle(
+    ur_native_handle_t hNativeProgram,              ///< [in][nocheck] the native handle of the program.
+    ur_context_handle_t hContext,                   ///< [in] handle of the context instance
+    const ur_program_native_properties_t* pProperties,  ///< [in][optional] pointer to native program properties struct.
+    ur_program_handle_t* phProgram                  ///< [out] pointer to the handle of the program object created.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create kernel object from a program.
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads.
 ///     - The implementation of this function should be lock-free.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3082,24 +3078,25 @@ ur_result_t UR_APICALL urProgramCreateWithNativeHandle(
 ///         + `NULL == phKernel`
 ///     - ::UR_RESULT_ERROR_INVALID_KERNEL_NAME
 ///         + If `pKernelName` wasn't found in `hProgram`.
-ur_result_t UR_APICALL urKernelCreate(
-    ur_program_handle_t hProgram, ///< [in] handle of the program instance
-    const char *pKernelName,      ///< [in] pointer to null-terminated string.
-    ur_kernel_handle_t
-        *phKernel ///< [out] pointer to handle of kernel object created.
-) {
+ur_result_t UR_APICALL
+urKernelCreate(
+    ur_program_handle_t hProgram,                   ///< [in] handle of the program instance
+    const char* pKernelName,                        ///< [in] pointer to null-terminated string.
+    ur_kernel_handle_t* phKernel                    ///< [out] pointer to handle of kernel object created.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Set kernel argument to a value.
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads with
 ///       the same kernel handle.
 ///     - The implementation of this function should be lock-free.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3111,28 +3108,28 @@ ur_result_t UR_APICALL urKernelCreate(
 ///         + `NULL == pArgValue`
 ///     - ::UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_INDEX
 ///     - ::UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_SIZE
-ur_result_t UR_APICALL urKernelSetArgValue(
-    ur_kernel_handle_t hKernel, ///< [in] handle of the kernel object
-    uint32_t argIndex, ///< [in] argument index in range [0, num args - 1]
-    size_t argSize,    ///< [in] size of argument type
-    const ur_kernel_arg_value_properties_t
-        *pProperties, ///< [in][optional] pointer to value properties.
-    const void
-        *pArgValue ///< [in] argument value represented as matching arg type.
-    ///< The data pointed to will be copied and therefore can be reused on return.
-) {
+ur_result_t UR_APICALL
+urKernelSetArgValue(
+    ur_kernel_handle_t hKernel,                     ///< [in] handle of the kernel object
+    uint32_t argIndex,                              ///< [in] argument index in range [0, num args - 1]
+    size_t argSize,                                 ///< [in] size of argument type
+    const ur_kernel_arg_value_properties_t* pProperties,///< [in][optional] pointer to value properties.
+    const void* pArgValue                           ///< [in] argument value represented as matching arg type.
+                                                    ///< The data pointed to will be copied and therefore can be reused on return.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Set kernel argument to a local buffer.
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads with
 ///       the same kernel handle.
 ///     - The implementation of this function should be lock-free.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3142,25 +3139,25 @@ ur_result_t UR_APICALL urKernelSetArgValue(
 ///         + `NULL == hKernel`
 ///     - ::UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_INDEX
 ///     - ::UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_SIZE
-ur_result_t UR_APICALL urKernelSetArgLocal(
-    ur_kernel_handle_t hKernel, ///< [in] handle of the kernel object
-    uint32_t argIndex, ///< [in] argument index in range [0, num args - 1]
-    size_t
-        argSize, ///< [in] size of the local buffer to be allocated by the runtime
-    const ur_kernel_arg_local_properties_t
-        *pProperties ///< [in][optional] pointer to local buffer properties.
-) {
+ur_result_t UR_APICALL
+urKernelSetArgLocal(
+    ur_kernel_handle_t hKernel,                     ///< [in] handle of the kernel object
+    uint32_t argIndex,                              ///< [in] argument index in range [0, num args - 1]
+    size_t argSize,                                 ///< [in] size of the local buffer to be allocated by the runtime
+    const ur_kernel_arg_local_properties_t* pProperties ///< [in][optional] pointer to local buffer properties.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Query information about a Kernel object
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clGetKernelInfo**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3181,32 +3178,32 @@ ur_result_t UR_APICALL urKernelSetArgLocal(
 ///     - ::UR_RESULT_ERROR_INVALID_KERNEL
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urKernelGetInfo(
-    ur_kernel_handle_t hKernel, ///< [in] handle of the Kernel object
-    ur_kernel_info_t propName,  ///< [in] name of the Kernel property to query
-    size_t propSize,            ///< [in] the size of the Kernel property value.
-    void *
-        pPropValue, ///< [in,out][optional][typename(propName, propSize)] array of bytes
-                    ///< holding the kernel info property.
-    ///< If propSize is not equal to or greater than the real number of bytes
-    ///< needed to return
-    ///< the info then the ::UR_RESULT_ERROR_INVALID_SIZE error is returned and
-    ///< pPropValue is not used.
-    size_t *
-        pPropSizeRet ///< [out][optional] pointer to the actual size in bytes of data being
-                     ///< queried by propName.
-) {
+ur_result_t UR_APICALL
+urKernelGetInfo(
+    ur_kernel_handle_t hKernel,                     ///< [in] handle of the Kernel object
+    ur_kernel_info_t propName,                      ///< [in] name of the Kernel property to query
+    size_t propSize,                                ///< [in] the size of the Kernel property value.
+    void* pPropValue,                               ///< [in,out][optional][typename(propName, propSize)] array of bytes
+                                                    ///< holding the kernel info property.
+                                                    ///< If propSize is not equal to or greater than the real number of bytes
+                                                    ///< needed to return
+                                                    ///< the info then the ::UR_RESULT_ERROR_INVALID_SIZE error is returned and
+                                                    ///< pPropValue is not used.
+    size_t* pPropSizeRet                            ///< [out][optional] pointer to the actual size in bytes of data being
+                                                    ///< queried by propName.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Query work Group information about a Kernel object
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clGetKernelWorkGroupInfo**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3217,26 +3214,25 @@ ur_result_t UR_APICALL urKernelGetInfo(
 ///         + `NULL == hDevice`
 ///     - ::UR_RESULT_ERROR_INVALID_ENUMERATION
 ///         + `::UR_KERNEL_GROUP_INFO_COMPILE_MAX_LINEAR_WORK_GROUP_SIZE < propName`
-ur_result_t UR_APICALL urKernelGetGroupInfo(
-    ur_kernel_handle_t hKernel, ///< [in] handle of the Kernel object
-    ur_device_handle_t hDevice, ///< [in] handle of the Device object
-    ur_kernel_group_info_t
-        propName,    ///< [in] name of the work Group property to query
-    size_t propSize, ///< [in] size of the Kernel Work Group property value
-    void *
-        pPropValue, ///< [in,out][optional][typename(propName, propSize)] value of the Kernel
-                    ///< Work Group property.
-    size_t *
-        pPropSizeRet ///< [out][optional] pointer to the actual size in bytes of data being
-                     ///< queried by propName.
-) {
+ur_result_t UR_APICALL
+urKernelGetGroupInfo(
+    ur_kernel_handle_t hKernel,                     ///< [in] handle of the Kernel object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the Device object
+    ur_kernel_group_info_t propName,                ///< [in] name of the work Group property to query
+    size_t propSize,                                ///< [in] size of the Kernel Work Group property value
+    void* pPropValue,                               ///< [in,out][optional][typename(propName, propSize)] value of the Kernel
+                                                    ///< Work Group property.
+    size_t* pPropSizeRet                            ///< [out][optional] pointer to the actual size in bytes of data being
+                                                    ///< queried by propName.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Query SubGroup information about a Kernel object
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3247,36 +3243,35 @@ ur_result_t UR_APICALL urKernelGetGroupInfo(
 ///         + `NULL == hDevice`
 ///     - ::UR_RESULT_ERROR_INVALID_ENUMERATION
 ///         + `::UR_KERNEL_SUB_GROUP_INFO_SUB_GROUP_SIZE_INTEL < propName`
-ur_result_t UR_APICALL urKernelGetSubGroupInfo(
-    ur_kernel_handle_t hKernel, ///< [in] handle of the Kernel object
-    ur_device_handle_t hDevice, ///< [in] handle of the Device object
-    ur_kernel_sub_group_info_t
-        propName,    ///< [in] name of the SubGroup property to query
-    size_t propSize, ///< [in] size of the Kernel SubGroup property value
-    void *
-        pPropValue, ///< [in,out][optional][typename(propName, propSize)] value of the Kernel
-                    ///< SubGroup property.
-    size_t *
-        pPropSizeRet ///< [out][optional] pointer to the actual size in bytes of data being
-                     ///< queried by propName.
-) {
+ur_result_t UR_APICALL
+urKernelGetSubGroupInfo(
+    ur_kernel_handle_t hKernel,                     ///< [in] handle of the Kernel object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the Device object
+    ur_kernel_sub_group_info_t propName,            ///< [in] name of the SubGroup property to query
+    size_t propSize,                                ///< [in] size of the Kernel SubGroup property value
+    void* pPropValue,                               ///< [in,out][optional][typename(propName, propSize)] value of the Kernel
+                                                    ///< SubGroup property.
+    size_t* pPropSizeRet                            ///< [out][optional] pointer to the actual size in bytes of data being
+                                                    ///< queried by propName.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Get a reference to the Kernel object.
-///
+/// 
 /// @details
 ///     - Get a reference to the Kernel object handle. Increment its reference
 ///       count
 ///     - The application may call this function from simultaneous threads.
 ///     - The implementation of this function should be lock-free.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clRetainKernel**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3284,26 +3279,28 @@ ur_result_t UR_APICALL urKernelGetSubGroupInfo(
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE
 ///         + `NULL == hKernel`
-ur_result_t UR_APICALL urKernelRetain(
-    ur_kernel_handle_t hKernel ///< [in][retain] handle for the Kernel to retain
-) {
+ur_result_t UR_APICALL
+urKernelRetain(
+    ur_kernel_handle_t hKernel                      ///< [in][retain] handle for the Kernel to retain
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Release Kernel.
-///
+/// 
 /// @details
 ///     - Decrement reference count and destroy the Kernel if reference count
 ///       becomes zero.
 ///     - The application may call this function from simultaneous threads.
 ///     - The implementation of this function should be lock-free.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clReleaseKernel**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3311,26 +3308,27 @@ ur_result_t UR_APICALL urKernelRetain(
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_HANDLE
 ///         + `NULL == hKernel`
-ur_result_t UR_APICALL urKernelRelease(
-    ur_kernel_handle_t
-        hKernel ///< [in][release] handle for the Kernel to release
-) {
+ur_result_t UR_APICALL
+urKernelRelease(
+    ur_kernel_handle_t hKernel                      ///< [in][release] handle for the Kernel to release
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Set a USM pointer as the argument value of a Kernel.
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads with
 ///       the same kernel handle.
 ///     - The implementation of this function should be lock-free.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clSetKernelArgSVMPointer**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3340,31 +3338,31 @@ ur_result_t UR_APICALL urKernelRelease(
 ///         + `NULL == hKernel`
 ///     - ::UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_INDEX
 ///     - ::UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_SIZE
-ur_result_t UR_APICALL urKernelSetArgPointer(
-    ur_kernel_handle_t hKernel, ///< [in] handle of the kernel object
-    uint32_t argIndex, ///< [in] argument index in range [0, num args - 1]
-    const ur_kernel_arg_pointer_properties_t
-        *pProperties, ///< [in][optional] pointer to USM pointer properties.
-    const void *
-        pArgValue ///< [in][optional] Pointer obtained by USM allocation or virtual memory
-    ///< mapping operation. If null then argument value is considered null.
-) {
+ur_result_t UR_APICALL
+urKernelSetArgPointer(
+    ur_kernel_handle_t hKernel,                     ///< [in] handle of the kernel object
+    uint32_t argIndex,                              ///< [in] argument index in range [0, num args - 1]
+    const ur_kernel_arg_pointer_properties_t* pProperties,  ///< [in][optional] pointer to USM pointer properties.
+    const void* pArgValue                           ///< [in][optional] Pointer obtained by USM allocation or virtual memory
+                                                    ///< mapping operation. If null then argument value is considered null.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Set additional Kernel execution attributes.
-///
+/// 
 /// @details
 ///     - The application must **not** call this function from simultaneous
 ///       threads with the same kernel handle.
 ///     - The implementation of this function should be lock-free.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clSetKernelExecInfo**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3376,28 +3374,28 @@ ur_result_t UR_APICALL urKernelSetArgPointer(
 ///         + `::UR_KERNEL_EXEC_INFO_CACHE_CONFIG < propName`
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_POINTER
 ///         + `NULL == pPropValue`
-ur_result_t UR_APICALL urKernelSetExecInfo(
-    ur_kernel_handle_t hKernel,     ///< [in] handle of the kernel object
-    ur_kernel_exec_info_t propName, ///< [in] name of the execution attribute
-    size_t propSize,                ///< [in] size in byte the attribute value
-    const ur_kernel_exec_info_properties_t
-        *pProperties, ///< [in][optional] pointer to execution info properties.
-    const void *
-        pPropValue ///< [in][typename(propName, propSize)] pointer to memory location holding
-                   ///< the property value.
-) {
+ur_result_t UR_APICALL
+urKernelSetExecInfo(
+    ur_kernel_handle_t hKernel,                     ///< [in] handle of the kernel object
+    ur_kernel_exec_info_t propName,                 ///< [in] name of the execution attribute
+    size_t propSize,                                ///< [in] size in byte the attribute value
+    const ur_kernel_exec_info_properties_t* pProperties,///< [in][optional] pointer to execution info properties.
+    const void* pPropValue                          ///< [in][typename(propName, propSize)] pointer to memory location holding
+                                                    ///< the property value.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Set a Sampler object as the argument value of a Kernel.
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads with
 ///       the same kernel handle.
 ///     - The implementation of this function should be lock-free.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3407,25 +3405,26 @@ ur_result_t UR_APICALL urKernelSetExecInfo(
 ///         + `NULL == hKernel`
 ///         + `NULL == hArgValue`
 ///     - ::UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_INDEX
-ur_result_t UR_APICALL urKernelSetArgSampler(
-    ur_kernel_handle_t hKernel, ///< [in] handle of the kernel object
-    uint32_t argIndex, ///< [in] argument index in range [0, num args - 1]
-    const ur_kernel_arg_sampler_properties_t
-        *pProperties, ///< [in][optional] pointer to sampler properties.
-    ur_sampler_handle_t hArgValue ///< [in] handle of Sampler object.
-) {
+ur_result_t UR_APICALL
+urKernelSetArgSampler(
+    ur_kernel_handle_t hKernel,                     ///< [in] handle of the kernel object
+    uint32_t argIndex,                              ///< [in] argument index in range [0, num args - 1]
+    const ur_kernel_arg_sampler_properties_t* pProperties,  ///< [in][optional] pointer to sampler properties.
+    ur_sampler_handle_t hArgValue                   ///< [in] handle of Sampler object.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Set a Memory object as the argument value of a Kernel.
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads with
 ///       the same kernel handle.
 ///     - The implementation of this function should be lock-free.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3436,20 +3435,21 @@ ur_result_t UR_APICALL urKernelSetArgSampler(
 ///     - ::UR_RESULT_ERROR_INVALID_ENUMERATION
 ///         + `NULL != pProperties && ::UR_MEM_FLAGS_MASK & pProperties->memoryAccess`
 ///     - ::UR_RESULT_ERROR_INVALID_KERNEL_ARGUMENT_INDEX
-ur_result_t UR_APICALL urKernelSetArgMemObj(
-    ur_kernel_handle_t hKernel, ///< [in] handle of the kernel object
-    uint32_t argIndex, ///< [in] argument index in range [0, num args - 1]
-    const ur_kernel_arg_mem_obj_properties_t
-        *pProperties, ///< [in][optional] pointer to Memory object properties.
-    ur_mem_handle_t hArgValue ///< [in][optional] handle of Memory object.
-) {
+ur_result_t UR_APICALL
+urKernelSetArgMemObj(
+    ur_kernel_handle_t hKernel,                     ///< [in] handle of the kernel object
+    uint32_t argIndex,                              ///< [in] argument index in range [0, num args - 1]
+    const ur_kernel_arg_mem_obj_properties_t* pProperties,  ///< [in][optional] pointer to Memory object properties.
+    ur_mem_handle_t hArgValue                       ///< [in][optional] handle of Memory object.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Set an array of specialization constants on a Kernel.
-///
+/// 
 /// @details
 ///     - This entry point is optional, the application should query for support
 ///       with device query ::UR_DEVICE_INFO_KERNEL_SET_SPECIALIZATION_CONSTANTS
@@ -3463,7 +3463,7 @@ ur_result_t UR_APICALL urKernelSetArgMemObj(
 ///     - The application may call this function from simultaneous threads for
 ///       the same device.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3482,19 +3482,20 @@ ur_result_t UR_APICALL urKernelSetArgMemObj(
 ///         + A pSpecConstant entry contains a nullptr pValue.
 ///     - ::UR_RESULT_ERROR_INVALID_SPEC_ID
 ///         + Any id specified in a pSpecConstant entry is not a valid specialization constant identifier.
-ur_result_t UR_APICALL urKernelSetSpecializationConstants(
-    ur_kernel_handle_t hKernel, ///< [in] handle of the kernel object
-    uint32_t count, ///< [in] the number of elements in the pSpecConstants array
-    const ur_specialization_constant_info_t *
-        pSpecConstants ///< [in] array of specialization constant value descriptions
-) {
+ur_result_t UR_APICALL
+urKernelSetSpecializationConstants(
+    ur_kernel_handle_t hKernel,                     ///< [in] handle of the kernel object
+    uint32_t count,                                 ///< [in] the number of elements in the pSpecConstants array
+    const ur_specialization_constant_info_t* pSpecConstants ///< [in] array of specialization constant value descriptions
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Return platform native kernel handle.
-///
+/// 
 /// @details
 ///     - Retrieved native handle can be used for direct interaction with the
 ///       native platform driver.
@@ -3503,7 +3504,7 @@ ur_result_t UR_APICALL urKernelSetSpecializationConstants(
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3515,18 +3516,19 @@ ur_result_t UR_APICALL urKernelSetSpecializationConstants(
 ///         + `NULL == phNativeKernel`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 ///         + If the adapter has no underlying equivalent handle.
-ur_result_t UR_APICALL urKernelGetNativeHandle(
-    ur_kernel_handle_t hKernel, ///< [in] handle of the kernel.
-    ur_native_handle_t
-        *phNativeKernel ///< [out] a pointer to the native handle of the kernel.
-) {
+ur_result_t UR_APICALL
+urKernelGetNativeHandle(
+    ur_kernel_handle_t hKernel,                     ///< [in] handle of the kernel.
+    ur_native_handle_t* phNativeKernel              ///< [out] a pointer to the native handle of the kernel.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create runtime kernel object from native kernel handle.
-///
+/// 
 /// @details
 ///     - Creates runtime kernel handle from native driver kernel handle.
 ///     - The application may call this function from simultaneous threads for
@@ -3534,7 +3536,7 @@ ur_result_t UR_APICALL urKernelGetNativeHandle(
 ///     - The implementation of this function should be thread-safe.
 ///     - The implementation may require a valid program handle to return the
 ///       native kernel handle
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3547,30 +3549,28 @@ ur_result_t UR_APICALL urKernelGetNativeHandle(
 ///         + `NULL == phKernel`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 ///         + If the adapter has no underlying equivalent handle.
-ur_result_t UR_APICALL urKernelCreateWithNativeHandle(
-    ur_native_handle_t
-        hNativeKernel, ///< [in][nocheck] the native handle of the kernel.
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_program_handle_t
-        hProgram, ///< [in][optional] handle of the program associated with the kernel
-    const ur_kernel_native_properties_t *
-        pProperties, ///< [in][optional] pointer to native kernel properties struct
-    ur_kernel_handle_t
-        *phKernel ///< [out] pointer to the handle of the kernel object created.
-) {
+ur_result_t UR_APICALL
+urKernelCreateWithNativeHandle(
+    ur_native_handle_t hNativeKernel,               ///< [in][nocheck] the native handle of the kernel.
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_program_handle_t hProgram,                   ///< [in][optional] handle of the program associated with the kernel
+    const ur_kernel_native_properties_t* pProperties,   ///< [in][optional] pointer to native kernel properties struct
+    ur_kernel_handle_t* phKernel                    ///< [out] pointer to the handle of the kernel object created.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Get the suggested local work size for a kernel.
-///
+/// 
 /// @details
 ///     - Query a suggested local work size for a kernel given a global size for
 ///       each dimension.
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3584,34 +3584,32 @@ ur_result_t UR_APICALL urKernelCreateWithNativeHandle(
 ///         + `NULL == pGlobalWorkSize`
 ///         + `NULL == pSuggestedLocalWorkSize`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
-ur_result_t UR_APICALL urKernelGetSuggestedLocalWorkSize(
-    ur_kernel_handle_t hKernel, ///< [in] handle of the kernel
-    ur_queue_handle_t hQueue,   ///< [in] handle of the queue object
-    uint32_t
-        numWorkDim, ///< [in] number of dimensions, from 1 to 3, to specify the global
-                    ///< and work-group work-items
-    const size_t *
-        pGlobalWorkOffset, ///< [in] pointer to an array of numWorkDim unsigned values that specify
-    ///< the offset used to calculate the global ID of a work-item
-    const size_t *
-        pGlobalWorkSize, ///< [in] pointer to an array of numWorkDim unsigned values that specify
-    ///< the number of global work-items in workDim that will execute the
-    ///< kernel function
-    size_t *
-        pSuggestedLocalWorkSize ///< [out] pointer to an array of numWorkDim unsigned values that specify
-    ///< suggested local work size that will contain the result of the query
-) {
+ur_result_t UR_APICALL
+urKernelGetSuggestedLocalWorkSize(
+    ur_kernel_handle_t hKernel,                     ///< [in] handle of the kernel
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    uint32_t numWorkDim,                            ///< [in] number of dimensions, from 1 to 3, to specify the global
+                                                    ///< and work-group work-items
+    const size_t* pGlobalWorkOffset,                ///< [in] pointer to an array of numWorkDim unsigned values that specify
+                                                    ///< the offset used to calculate the global ID of a work-item
+    const size_t* pGlobalWorkSize,                  ///< [in] pointer to an array of numWorkDim unsigned values that specify
+                                                    ///< the number of global work-items in workDim that will execute the
+                                                    ///< kernel function
+    size_t* pSuggestedLocalWorkSize                 ///< [out] pointer to an array of numWorkDim unsigned values that specify
+                                                    ///< suggested local work size that will contain the result of the query
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Query information about a command queue
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clGetCommandQueueInfo**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3632,31 +3630,30 @@ ur_result_t UR_APICALL urKernelGetSuggestedLocalWorkSize(
 ///     - ::UR_RESULT_ERROR_INVALID_QUEUE - "If `hQueue` isn't a valid queue handle or if `propName` isn't supported by `hQueue`."
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urQueueGetInfo(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    ur_queue_info_t propName, ///< [in] name of the queue property to query
-    size_t
-        propSize, ///< [in] size in bytes of the queue property value provided
-    void *
-        pPropValue, ///< [out][optional][typename(propName, propSize)] value of the queue
-                    ///< property
-    size_t *
-        pPropSizeRet ///< [out][optional] size in bytes returned in queue property value
-) {
+ur_result_t UR_APICALL
+urQueueGetInfo(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    ur_queue_info_t propName,                       ///< [in] name of the queue property to query
+    size_t propSize,                                ///< [in] size in bytes of the queue property value provided
+    void* pPropValue,                               ///< [out][optional][typename(propName, propSize)] value of the queue
+                                                    ///< property
+    size_t* pPropSizeRet                            ///< [out][optional] size in bytes returned in queue property value
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create a command queue for a device in a context
-///
+/// 
 /// @details
 ///     - See also ::ur_queue_index_properties_t.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clCreateCommandQueueWithProperties**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3676,14 +3673,14 @@ ur_result_t UR_APICALL urQueueGetInfo(
 ///         + `pProperties != NULL && pProperties->flags & UR_QUEUE_FLAG_SUBMISSION_BATCHED && pProperties->flags & UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE`
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urQueueCreate(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_device_handle_t hDevice,   ///< [in] handle of the device object
-    const ur_queue_properties_t
-        *pProperties, ///< [in][optional] pointer to queue creation properties.
-    ur_queue_handle_t
-        *phQueue ///< [out] pointer to handle of queue object created
-) {
+ur_result_t UR_APICALL
+urQueueCreate(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device object
+    const ur_queue_properties_t* pProperties,       ///< [in][optional] pointer to queue creation properties.
+    ur_queue_handle_t* phQueue                      ///< [out] pointer to handle of queue object created
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -3691,15 +3688,15 @@ ur_result_t UR_APICALL urQueueCreate(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Get a reference to the command queue handle. Increment the command
 ///        queue's reference count
-///
+/// 
 /// @details
 ///     - Useful in library function to retain access to the command queue after
 ///       the caller released the queue.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clRetainCommandQueue**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3710,10 +3707,11 @@ ur_result_t UR_APICALL urQueueCreate(
 ///     - ::UR_RESULT_ERROR_INVALID_QUEUE
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urQueueRetain(
-    ur_queue_handle_t
-        hQueue ///< [in][retain] handle of the queue object to get access
-) {
+ur_result_t UR_APICALL
+urQueueRetain(
+    ur_queue_handle_t hQueue                        ///< [in][retain] handle of the queue object to get access
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -3721,17 +3719,17 @@ ur_result_t UR_APICALL urQueueRetain(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Decrement the command queue's reference count and delete the command
 ///        queue if the reference count becomes zero.
-///
+/// 
 /// @details
 ///     - After the command queue reference count becomes zero and all queued
 ///       commands in the queue have finished, the queue is deleted.
 ///     - It also performs an implicit flush to issue all previously queued
 ///       commands in the queue.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clReleaseCommandQueue**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3742,17 +3740,18 @@ ur_result_t UR_APICALL urQueueRetain(
 ///     - ::UR_RESULT_ERROR_INVALID_QUEUE
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urQueueRelease(
-    ur_queue_handle_t
-        hQueue ///< [in][release] handle of the queue object to release
-) {
+ur_result_t UR_APICALL
+urQueueRelease(
+    ur_queue_handle_t hQueue                        ///< [in][release] handle of the queue object to release
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Return queue native queue handle.
-///
+/// 
 /// @details
 ///     - Retrieved native handle can be used for direct interaction with the
 ///       native platform driver.
@@ -3761,7 +3760,7 @@ ur_result_t UR_APICALL urQueueRelease(
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3773,26 +3772,26 @@ ur_result_t UR_APICALL urQueueRelease(
 ///         + `NULL == phNativeQueue`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 ///         + If the adapter has no underlying equivalent handle.
-ur_result_t UR_APICALL urQueueGetNativeHandle(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue.
-    ur_queue_native_desc_t
-        *pDesc, ///< [in][optional] pointer to native descriptor
-    ur_native_handle_t
-        *phNativeQueue ///< [out] a pointer to the native handle of the queue.
-) {
+ur_result_t UR_APICALL
+urQueueGetNativeHandle(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue.
+    ur_queue_native_desc_t* pDesc,                  ///< [in][optional] pointer to native descriptor
+    ur_native_handle_t* phNativeQueue               ///< [out] a pointer to the native handle of the queue.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create runtime queue object from native queue handle.
-///
+/// 
 /// @details
 ///     - Creates runtime queue handle from native driver queue handle.
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3804,16 +3803,15 @@ ur_result_t UR_APICALL urQueueGetNativeHandle(
 ///         + `NULL == phQueue`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 ///         + If the adapter has no underlying equivalent handle.
-ur_result_t UR_APICALL urQueueCreateWithNativeHandle(
-    ur_native_handle_t
-        hNativeQueue, ///< [in][nocheck] the native handle of the queue.
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_device_handle_t hDevice, ///< [in][optional] handle of the device object
-    const ur_queue_native_properties_t *
-        pProperties, ///< [in][optional] pointer to native queue properties struct
-    ur_queue_handle_t
-        *phQueue ///< [out] pointer to the handle of the queue object created.
-) {
+ur_result_t UR_APICALL
+urQueueCreateWithNativeHandle(
+    ur_native_handle_t hNativeQueue,                ///< [in][nocheck] the native handle of the queue.
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_device_handle_t hDevice,                     ///< [in][optional] handle of the device object
+    const ur_queue_native_properties_t* pProperties,///< [in][optional] pointer to native queue properties struct
+    ur_queue_handle_t* phQueue                      ///< [out] pointer to the handle of the queue object created.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -3821,18 +3819,18 @@ ur_result_t UR_APICALL urQueueCreateWithNativeHandle(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Blocks until all previously issued commands to the command queue are
 ///        finished.
-///
+/// 
 /// @details
 ///     - Blocks until all previously issued commands to the command queue are
 ///       issued and completed.
 ///     - ::urQueueFinish does not return until all enqueued commands have been
 ///       processed and finished.
 ///     - ::urQueueFinish acts as a synchronization point.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clFinish**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3842,9 +3840,11 @@ ur_result_t UR_APICALL urQueueCreateWithNativeHandle(
 ///         + `NULL == hQueue`
 ///     - ::UR_RESULT_ERROR_INVALID_QUEUE
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urQueueFinish(
-    ur_queue_handle_t hQueue ///< [in] handle of the queue to be finished.
-) {
+ur_result_t UR_APICALL
+urQueueFinish(
+    ur_queue_handle_t hQueue                        ///< [in] handle of the queue to be finished.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -3852,17 +3852,17 @@ ur_result_t UR_APICALL urQueueFinish(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Issues all previously enqueued commands in a command queue to the
 ///        device.
-///
+/// 
 /// @details
 ///     - Guarantees that all enqueued commands will be issued to the
 ///       appropriate device.
 ///     - There is no guarantee that they will be completed after ::urQueueFlush
 ///       returns.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clFlush**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3872,20 +3872,22 @@ ur_result_t UR_APICALL urQueueFinish(
 ///         + `NULL == hQueue`
 ///     - ::UR_RESULT_ERROR_INVALID_QUEUE
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urQueueFlush(
-    ur_queue_handle_t hQueue ///< [in] handle of the queue to be flushed.
-) {
+ur_result_t UR_APICALL
+urQueueFlush(
+    ur_queue_handle_t hQueue                        ///< [in] handle of the queue to be flushed.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Get event object information
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clGetEventInfo**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3906,15 +3908,16 @@ ur_result_t UR_APICALL urQueueFlush(
 ///     - ::UR_RESULT_ERROR_INVALID_EVENT
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urEventGetInfo(
-    ur_event_handle_t hEvent, ///< [in] handle of the event object
-    ur_event_info_t propName, ///< [in] the name of the event property to query
-    size_t propSize, ///< [in] size in bytes of the event property value
-    void *
-        pPropValue, ///< [out][optional][typename(propName, propSize)] value of the event
-                    ///< property
-    size_t *pPropSizeRet ///< [out][optional] bytes returned in event property
-) {
+ur_result_t UR_APICALL
+urEventGetInfo(
+    ur_event_handle_t hEvent,                       ///< [in] handle of the event object
+    ur_event_info_t propName,                       ///< [in] the name of the event property to query
+    size_t propSize,                                ///< [in] size in bytes of the event property value
+    void* pPropValue,                               ///< [out][optional][typename(propName, propSize)] value of the event
+                                                    ///< property
+    size_t* pPropSizeRet                            ///< [out][optional] bytes returned in event property
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -3922,11 +3925,11 @@ ur_result_t UR_APICALL urEventGetInfo(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Get profiling information for the command associated with an event
 ///        object
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clGetEventProfilingInfo**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3943,29 +3946,28 @@ ur_result_t UR_APICALL urEventGetInfo(
 ///     - ::UR_RESULT_ERROR_INVALID_EVENT
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urEventGetProfilingInfo(
-    ur_event_handle_t hEvent, ///< [in] handle of the event object
-    ur_profiling_info_t
-        propName,    ///< [in] the name of the profiling property to query
-    size_t propSize, ///< [in] size in bytes of the profiling property value
-    void *
-        pPropValue, ///< [out][optional][typename(propName, propSize)] value of the profiling
-                    ///< property
-    size_t *
-        pPropSizeRet ///< [out][optional] pointer to the actual size in bytes returned in
-                     ///< propValue
-) {
+ur_result_t UR_APICALL
+urEventGetProfilingInfo(
+    ur_event_handle_t hEvent,                       ///< [in] handle of the event object
+    ur_profiling_info_t propName,                   ///< [in] the name of the profiling property to query
+    size_t propSize,                                ///< [in] size in bytes of the profiling property value
+    void* pPropValue,                               ///< [out][optional][typename(propName, propSize)] value of the profiling
+                                                    ///< property
+    size_t* pPropSizeRet                            ///< [out][optional] pointer to the actual size in bytes returned in
+                                                    ///< propValue
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Wait for a list of events to finish.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clWaitForEvent**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -3981,12 +3983,13 @@ ur_result_t UR_APICALL urEventGetProfilingInfo(
 ///     - ::UR_RESULT_ERROR_INVALID_CONTEXT
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEventWait(
-    uint32_t numEvents, ///< [in] number of events in the event list
-    const ur_event_handle_t *
-        phEventWaitList ///< [in][range(0, numEvents)] pointer to a list of events to wait for
-                        ///< completion
-) {
+ur_result_t UR_APICALL
+urEventWait(
+    uint32_t numEvents,                             ///< [in] number of events in the event list
+    const ur_event_handle_t* phEventWaitList        ///< [in][range(0, numEvents)] pointer to a list of events to wait for
+                                                    ///< completion
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -3994,11 +3997,11 @@ ur_result_t UR_APICALL urEventWait(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Get a reference to an event handle. Increment the event object's
 ///        reference count.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clRetainEvent**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -4009,9 +4012,11 @@ ur_result_t UR_APICALL urEventWait(
 ///     - ::UR_RESULT_ERROR_INVALID_EVENT
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urEventRetain(
-    ur_event_handle_t hEvent ///< [in][retain] handle of the event object
-) {
+ur_result_t UR_APICALL
+urEventRetain(
+    ur_event_handle_t hEvent                        ///< [in][retain] handle of the event object
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -4019,11 +4024,11 @@ ur_result_t UR_APICALL urEventRetain(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Decrement the event object's reference count and delete the event
 ///        object if the reference count becomes zero.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clReleaseEvent**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -4034,16 +4039,18 @@ ur_result_t UR_APICALL urEventRetain(
 ///     - ::UR_RESULT_ERROR_INVALID_EVENT
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urEventRelease(
-    ur_event_handle_t hEvent ///< [in][release] handle of the event object
-) {
+ur_result_t UR_APICALL
+urEventRelease(
+    ur_event_handle_t hEvent                        ///< [in][release] handle of the event object
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Return platform native event handle.
-///
+/// 
 /// @details
 ///     - Retrieved native handle can be used for direct interaction with the
 ///       native platform driver.
@@ -4052,7 +4059,7 @@ ur_result_t UR_APICALL urEventRelease(
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -4064,24 +4071,25 @@ ur_result_t UR_APICALL urEventRelease(
 ///         + `NULL == phNativeEvent`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 ///         + If the adapter has no underlying equivalent handle.
-ur_result_t UR_APICALL urEventGetNativeHandle(
-    ur_event_handle_t hEvent, ///< [in] handle of the event.
-    ur_native_handle_t
-        *phNativeEvent ///< [out] a pointer to the native handle of the event.
-) {
+ur_result_t UR_APICALL
+urEventGetNativeHandle(
+    ur_event_handle_t hEvent,                       ///< [in] handle of the event.
+    ur_native_handle_t* phNativeEvent               ///< [out] a pointer to the native handle of the event.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create runtime event object from native event handle.
-///
+/// 
 /// @details
 ///     - Creates runtime event handle from native driver event handle.
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -4093,15 +4101,14 @@ ur_result_t UR_APICALL urEventGetNativeHandle(
 ///         + `NULL == phEvent`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
 ///         + If the adapter has no underlying equivalent handle.
-ur_result_t UR_APICALL urEventCreateWithNativeHandle(
-    ur_native_handle_t
-        hNativeEvent, ///< [in][nocheck] the native handle of the event.
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    const ur_event_native_properties_t *
-        pProperties, ///< [in][optional] pointer to native event properties struct
-    ur_event_handle_t
-        *phEvent ///< [out] pointer to the handle of the event object created.
-) {
+ur_result_t UR_APICALL
+urEventCreateWithNativeHandle(
+    ur_native_handle_t hNativeEvent,                ///< [in][nocheck] the native handle of the event.
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    const ur_event_native_properties_t* pProperties,///< [in][optional] pointer to native event properties struct
+    ur_event_handle_t* phEvent                      ///< [out] pointer to the handle of the event object created.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -4109,7 +4116,7 @@ ur_result_t UR_APICALL urEventCreateWithNativeHandle(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Register a user callback function for a specific command execution
 ///        status.
-///
+/// 
 /// @details
 ///     - The registered callback function will be called when the execution
 ///       status of command associated with event changes to an execution status
@@ -4119,7 +4126,7 @@ ur_result_t UR_APICALL urEventCreateWithNativeHandle(
 ///     - The application may call this function from simultaneous threads for
 ///       the same context.
 ///     - The implementation of this function should be thread-safe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -4133,24 +4140,25 @@ ur_result_t UR_APICALL urEventCreateWithNativeHandle(
 ///         + `NULL == pfnNotify`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION
 ///         + `execStatus == UR_EXECUTION_INFO_QUEUED`
-ur_result_t UR_APICALL urEventSetCallback(
-    ur_event_handle_t hEvent,       ///< [in] handle of the event object
-    ur_execution_info_t execStatus, ///< [in] execution status of the event
-    ur_event_callback_t pfnNotify,  ///< [in] execution status of the event
-    void *
-        pUserData ///< [in][out][optional] pointer to data to be passed to callback.
-) {
+ur_result_t UR_APICALL
+urEventSetCallback(
+    ur_event_handle_t hEvent,                       ///< [in] handle of the event object
+    ur_execution_info_t execStatus,                 ///< [in] execution status of the event
+    ur_event_callback_t pfnNotify,                  ///< [in] execution status of the event
+    void* pUserData                                 ///< [in][out][optional] pointer to data to be passed to callback.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to execute a kernel
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clEnqueueNDRangeKernel**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -4177,34 +4185,30 @@ ur_result_t UR_APICALL urEventSetCallback(
 ///     - ::UR_RESULT_ERROR_INVALID_KERNEL_ARGS - "The kernel argument values have not been specified."
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueKernelLaunch(
-    ur_queue_handle_t hQueue,   ///< [in] handle of the queue object
-    ur_kernel_handle_t hKernel, ///< [in] handle of the kernel object
-    uint32_t
-        workDim, ///< [in] number of dimensions, from 1 to 3, to specify the global and
-                 ///< work-group work-items
-    const size_t *
-        pGlobalWorkOffset, ///< [in] pointer to an array of workDim unsigned values that specify the
-    ///< offset used to calculate the global ID of a work-item
-    const size_t *
-        pGlobalWorkSize, ///< [in] pointer to an array of workDim unsigned values that specify the
-    ///< number of global work-items in workDim that will execute the kernel
-    ///< function
-    const size_t *
-        pLocalWorkSize, ///< [in][optional] pointer to an array of workDim unsigned values that
-    ///< specify the number of local work-items forming a work-group that will
-    ///< execute the kernel function.
-    ///< If nullptr, the runtime implementation will choose the work-group size.
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the kernel execution.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that no wait event.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< kernel execution instance. If phEventWaitList and phEvent are not
-    ///< NULL, phEvent must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueKernelLaunch(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    ur_kernel_handle_t hKernel,                     ///< [in] handle of the kernel object
+    uint32_t workDim,                               ///< [in] number of dimensions, from 1 to 3, to specify the global and
+                                                    ///< work-group work-items
+    const size_t* pGlobalWorkOffset,                ///< [in] pointer to an array of workDim unsigned values that specify the
+                                                    ///< offset used to calculate the global ID of a work-item
+    const size_t* pGlobalWorkSize,                  ///< [in] pointer to an array of workDim unsigned values that specify the
+                                                    ///< number of global work-items in workDim that will execute the kernel
+                                                    ///< function
+    const size_t* pLocalWorkSize,                   ///< [in][optional] pointer to an array of workDim unsigned values that
+                                                    ///< specify the number of local work-items forming a work-group that will
+                                                    ///< execute the kernel function.
+                                                    ///< If nullptr, the runtime implementation will choose the work-group size.
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the kernel execution.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that no wait event.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< kernel execution instance. If phEventWaitList and phEvent are not
+                                                    ///< NULL, phEvent must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -4212,16 +4216,16 @@ ur_result_t UR_APICALL urEnqueueKernelLaunch(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command which waits a list of events to complete before it
 ///        completes
-///
+/// 
 /// @details
 ///     - If the event list is empty, it waits for all previously enqueued
 ///       commands to complete.
 ///     - It returns an event which can be waited on.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clEnqueueMarkerWithWaitList**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -4240,20 +4244,20 @@ ur_result_t UR_APICALL urEnqueueKernelLaunch(
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueEventsWait(
-    ur_queue_handle_t hQueue,     ///< [in] handle of the queue object
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that all
-    ///< previously enqueued commands
-    ///< must be complete.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueEventsWait(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that all
+                                                    ///< previously enqueued commands
+                                                    ///< must be complete.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -4261,18 +4265,18 @@ ur_result_t UR_APICALL urEnqueueEventsWait(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a barrier command which waits a list of events to complete
 ///        before it completes
-///
+/// 
 /// @details
 ///     - If the event list is empty, it waits for all previously enqueued
 ///       commands to complete.
 ///     - It blocks command execution - any following commands enqueued after it
 ///       do not execute until it completes.
 ///     - It returns an event which can be waited on.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clEnqueueBarrierWithWaitList**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -4291,35 +4295,35 @@ ur_result_t UR_APICALL urEnqueueEventsWait(
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueEventsWaitWithBarrier(
-    ur_queue_handle_t hQueue,     ///< [in] handle of the queue object
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that all
-    ///< previously enqueued commands
-    ///< must be complete.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueEventsWaitWithBarrier(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that all
+                                                    ///< previously enqueued commands
+                                                    ///< must be complete.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to read from a buffer object to host memory
-///
+/// 
 /// @details
 ///     - Input parameter blockingRead indicates if the read is blocking or
 ///       non-blocking.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clEnqueueReadBuffer**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -4343,40 +4347,39 @@ ur_result_t UR_APICALL urEnqueueEventsWaitWithBarrier(
 ///         + If `offset + size` results in an out-of-bounds access.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueMemBufferRead(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    ur_mem_handle_t
-        hBuffer, ///< [in][bounds(offset, size)] handle of the buffer object
-    bool blockingRead, ///< [in] indicates blocking (true), non-blocking (false)
-    size_t offset,     ///< [in] offset in bytes in the buffer object
-    size_t size,       ///< [in] size in bytes of data being read
-    void *pDst, ///< [in] pointer to host memory where data is to be read into
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
-    ///< command does not wait on any event to complete.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueMemBufferRead(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    ur_mem_handle_t hBuffer,                        ///< [in][bounds(offset, size)] handle of the buffer object
+    bool blockingRead,                              ///< [in] indicates blocking (true), non-blocking (false)
+    size_t offset,                                  ///< [in] offset in bytes in the buffer object
+    size_t size,                                    ///< [in] size in bytes of data being read
+    void* pDst,                                     ///< [in] pointer to host memory where data is to be read into
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
+                                                    ///< command does not wait on any event to complete.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to write into a buffer object from host memory
-///
+/// 
 /// @details
 ///     - Input parameter blockingWrite indicates if the write is blocking or
 ///       non-blocking.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clEnqueueWriteBuffer**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -4400,27 +4403,24 @@ ur_result_t UR_APICALL urEnqueueMemBufferRead(
 ///         + If `offset + size` results in an out-of-bounds access.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueMemBufferWrite(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    ur_mem_handle_t
-        hBuffer, ///< [in][bounds(offset, size)] handle of the buffer object
-    bool
-        blockingWrite, ///< [in] indicates blocking (true), non-blocking (false)
-    size_t offset,     ///< [in] offset in bytes in the buffer object
-    size_t size,       ///< [in] size in bytes of data being written
-    const void
-        *pSrc, ///< [in] pointer to host memory where data is to be written from
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
-    ///< command does not wait on any event to complete.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueMemBufferWrite(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    ur_mem_handle_t hBuffer,                        ///< [in][bounds(offset, size)] handle of the buffer object
+    bool blockingWrite,                             ///< [in] indicates blocking (true), non-blocking (false)
+    size_t offset,                                  ///< [in] offset in bytes in the buffer object
+    size_t size,                                    ///< [in] size in bytes of data being written
+    const void* pSrc,                               ///< [in] pointer to host memory where data is to be written from
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
+                                                    ///< command does not wait on any event to complete.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -4428,17 +4428,17 @@ ur_result_t UR_APICALL urEnqueueMemBufferWrite(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to read a 2D or 3D rectangular region from a buffer
 ///        object to host memory
-///
+/// 
 /// @details
 ///     - Input parameter blockingRead indicates if the read is blocking or
 ///       non-blocking.
 ///     - The buffer and host 2D or 3D rectangular regions can have different
 ///       shapes.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clEnqueueReadBufferRect**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -4469,37 +4469,31 @@ ur_result_t UR_APICALL urEnqueueMemBufferWrite(
 ///         + If the combination of `bufferOrigin`, `region`, `bufferRowPitch`, and `bufferSlicePitch` results in an out-of-bounds access.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueMemBufferReadRect(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    ur_mem_handle_t
-        hBuffer, ///< [in][bounds(bufferOrigin, region)] handle of the buffer object
-    bool blockingRead, ///< [in] indicates blocking (true), non-blocking (false)
-    ur_rect_offset_t bufferOrigin, ///< [in] 3D offset in the buffer
-    ur_rect_offset_t hostOrigin,   ///< [in] 3D offset in the host region
-    ur_rect_region_t
-        region, ///< [in] 3D rectangular region descriptor: width, height, depth
-    size_t
-        bufferRowPitch, ///< [in] length of each row in bytes in the buffer object
-    size_t
-        bufferSlicePitch, ///< [in] length of each 2D slice in bytes in the buffer object being read
-    size_t
-        hostRowPitch, ///< [in] length of each row in bytes in the host memory region pointed by
-                      ///< dst
-    size_t
-        hostSlicePitch, ///< [in] length of each 2D slice in bytes in the host memory region
-                        ///< pointed by dst
-    void *pDst, ///< [in] pointer to host memory where data is to be read into
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
-    ///< command does not wait on any event to complete.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueMemBufferReadRect(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    ur_mem_handle_t hBuffer,                        ///< [in][bounds(bufferOrigin, region)] handle of the buffer object
+    bool blockingRead,                              ///< [in] indicates blocking (true), non-blocking (false)
+    ur_rect_offset_t bufferOrigin,                  ///< [in] 3D offset in the buffer
+    ur_rect_offset_t hostOrigin,                    ///< [in] 3D offset in the host region
+    ur_rect_region_t region,                        ///< [in] 3D rectangular region descriptor: width, height, depth
+    size_t bufferRowPitch,                          ///< [in] length of each row in bytes in the buffer object
+    size_t bufferSlicePitch,                        ///< [in] length of each 2D slice in bytes in the buffer object being read
+    size_t hostRowPitch,                            ///< [in] length of each row in bytes in the host memory region pointed by
+                                                    ///< dst
+    size_t hostSlicePitch,                          ///< [in] length of each 2D slice in bytes in the host memory region
+                                                    ///< pointed by dst
+    void* pDst,                                     ///< [in] pointer to host memory where data is to be read into
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
+                                                    ///< command does not wait on any event to complete.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -4507,17 +4501,17 @@ ur_result_t UR_APICALL urEnqueueMemBufferReadRect(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to write a 2D or 3D rectangular region in a buffer
 ///        object from host memory
-///
+/// 
 /// @details
 ///     - Input parameter blockingWrite indicates if the write is blocking or
 ///       non-blocking.
 ///     - The buffer and host 2D or 3D rectangular regions can have different
 ///       shapes.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clEnqueueWriteBufferRect**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -4548,51 +4542,43 @@ ur_result_t UR_APICALL urEnqueueMemBufferReadRect(
 ///         + If the combination of `bufferOrigin`, `region`, `bufferRowPitch`, and `bufferSlicePitch` results in an out-of-bounds access.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueMemBufferWriteRect(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    ur_mem_handle_t
-        hBuffer, ///< [in][bounds(bufferOrigin, region)] handle of the buffer object
-    bool
-        blockingWrite, ///< [in] indicates blocking (true), non-blocking (false)
-    ur_rect_offset_t bufferOrigin, ///< [in] 3D offset in the buffer
-    ur_rect_offset_t hostOrigin,   ///< [in] 3D offset in the host region
-    ur_rect_region_t
-        region, ///< [in] 3D rectangular region descriptor: width, height, depth
-    size_t
-        bufferRowPitch, ///< [in] length of each row in bytes in the buffer object
-    size_t
-        bufferSlicePitch, ///< [in] length of each 2D slice in bytes in the buffer object being
-                          ///< written
-    size_t
-        hostRowPitch, ///< [in] length of each row in bytes in the host memory region pointed by
-                      ///< src
-    size_t
-        hostSlicePitch, ///< [in] length of each 2D slice in bytes in the host memory region
-                        ///< pointed by src
-    void
-        *pSrc, ///< [in] pointer to host memory where data is to be written from
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] points to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
-    ///< command does not wait on any event to complete.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueMemBufferWriteRect(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    ur_mem_handle_t hBuffer,                        ///< [in][bounds(bufferOrigin, region)] handle of the buffer object
+    bool blockingWrite,                             ///< [in] indicates blocking (true), non-blocking (false)
+    ur_rect_offset_t bufferOrigin,                  ///< [in] 3D offset in the buffer
+    ur_rect_offset_t hostOrigin,                    ///< [in] 3D offset in the host region
+    ur_rect_region_t region,                        ///< [in] 3D rectangular region descriptor: width, height, depth
+    size_t bufferRowPitch,                          ///< [in] length of each row in bytes in the buffer object
+    size_t bufferSlicePitch,                        ///< [in] length of each 2D slice in bytes in the buffer object being
+                                                    ///< written
+    size_t hostRowPitch,                            ///< [in] length of each row in bytes in the host memory region pointed by
+                                                    ///< src
+    size_t hostSlicePitch,                          ///< [in] length of each 2D slice in bytes in the host memory region
+                                                    ///< pointed by src
+    void* pSrc,                                     ///< [in] pointer to host memory where data is to be written from
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] points to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
+                                                    ///< command does not wait on any event to complete.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to copy from a buffer object to another
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clEnqueueCopyBuffer**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -4616,26 +4602,24 @@ ur_result_t UR_APICALL urEnqueueMemBufferWriteRect(
 ///         + If `dstOffset + size` results in an out-of-bounds access.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueMemBufferCopy(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    ur_mem_handle_t
-        hBufferSrc, ///< [in][bounds(srcOffset, size)] handle of the src buffer object
-    ur_mem_handle_t
-        hBufferDst, ///< [in][bounds(dstOffset, size)] handle of the dest buffer object
-    size_t srcOffset, ///< [in] offset into hBufferSrc to begin copying from
-    size_t dstOffset, ///< [in] offset info hBufferDst to begin copying into
-    size_t size,      ///< [in] size in bytes of data being copied
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
-    ///< command does not wait on any event to complete.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueMemBufferCopy(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    ur_mem_handle_t hBufferSrc,                     ///< [in][bounds(srcOffset, size)] handle of the src buffer object
+    ur_mem_handle_t hBufferDst,                     ///< [in][bounds(dstOffset, size)] handle of the dest buffer object
+    size_t srcOffset,                               ///< [in] offset into hBufferSrc to begin copying from
+    size_t dstOffset,                               ///< [in] offset info hBufferDst to begin copying into
+    size_t size,                                    ///< [in] size in bytes of data being copied
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
+                                                    ///< command does not wait on any event to complete.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -4643,11 +4627,11 @@ ur_result_t UR_APICALL urEnqueueMemBufferCopy(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to copy a 2D or 3D rectangular region from one
 ///        buffer object to another
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clEnqueueCopyBufferRect**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -4678,35 +4662,28 @@ ur_result_t UR_APICALL urEnqueueMemBufferCopy(
 ///         + If the combination of `dstOrigin`, `region`, `dstRowPitch`, and `dstSlicePitch` results in an out-of-bounds access.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueMemBufferCopyRect(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    ur_mem_handle_t
-        hBufferSrc, ///< [in][bounds(srcOrigin, region)] handle of the source buffer object
-    ur_mem_handle_t
-        hBufferDst, ///< [in][bounds(dstOrigin, region)] handle of the dest buffer object
-    ur_rect_offset_t srcOrigin, ///< [in] 3D offset in the source buffer
-    ur_rect_offset_t dstOrigin, ///< [in] 3D offset in the destination buffer
-    ur_rect_region_t
-        region, ///< [in] source 3D rectangular region descriptor: width, height, depth
-    size_t
-        srcRowPitch, ///< [in] length of each row in bytes in the source buffer object
-    size_t
-        srcSlicePitch, ///< [in] length of each 2D slice in bytes in the source buffer object
-    size_t
-        dstRowPitch, ///< [in] length of each row in bytes in the destination buffer object
-    size_t
-        dstSlicePitch, ///< [in] length of each 2D slice in bytes in the destination buffer object
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
-    ///< command does not wait on any event to complete.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueMemBufferCopyRect(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    ur_mem_handle_t hBufferSrc,                     ///< [in][bounds(srcOrigin, region)] handle of the source buffer object
+    ur_mem_handle_t hBufferDst,                     ///< [in][bounds(dstOrigin, region)] handle of the dest buffer object
+    ur_rect_offset_t srcOrigin,                     ///< [in] 3D offset in the source buffer
+    ur_rect_offset_t dstOrigin,                     ///< [in] 3D offset in the destination buffer
+    ur_rect_region_t region,                        ///< [in] source 3D rectangular region descriptor: width, height, depth
+    size_t srcRowPitch,                             ///< [in] length of each row in bytes in the source buffer object
+    size_t srcSlicePitch,                           ///< [in] length of each 2D slice in bytes in the source buffer object
+    size_t dstRowPitch,                             ///< [in] length of each row in bytes in the destination buffer object
+    size_t dstSlicePitch,                           ///< [in] length of each 2D slice in bytes in the destination buffer object
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
+                                                    ///< command does not wait on any event to complete.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -4714,11 +4691,11 @@ ur_result_t UR_APICALL urEnqueueMemBufferCopyRect(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to fill a buffer object with a pattern of a given
 ///        size
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clEnqueueFillBuffer**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -4747,25 +4724,24 @@ ur_result_t UR_APICALL urEnqueueMemBufferCopyRect(
 ///         + If `offset + size` results in an out-of-bounds access.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueMemBufferFill(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    ur_mem_handle_t
-        hBuffer, ///< [in][bounds(offset, size)] handle of the buffer object
-    const void *pPattern, ///< [in] pointer to the fill pattern
-    size_t patternSize,   ///< [in] size in bytes of the pattern
-    size_t offset,        ///< [in] offset into the buffer
-    size_t size, ///< [in] fill size in bytes, must be a multiple of patternSize
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
-    ///< command does not wait on any event to complete.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueMemBufferFill(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    ur_mem_handle_t hBuffer,                        ///< [in][bounds(offset, size)] handle of the buffer object
+    const void* pPattern,                           ///< [in] pointer to the fill pattern
+    size_t patternSize,                             ///< [in] size in bytes of the pattern
+    size_t offset,                                  ///< [in] offset into the buffer
+    size_t size,                                    ///< [in] fill size in bytes, must be a multiple of patternSize
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
+                                                    ///< command does not wait on any event to complete.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -4773,15 +4749,15 @@ ur_result_t UR_APICALL urEnqueueMemBufferFill(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to read from an image or image array object to host
 ///        memory
-///
+/// 
 /// @details
 ///     - Input parameter blockingRead indicates if the read is blocking or
 ///       non-blocking.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clEnqueueReadImage**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -4805,30 +4781,27 @@ ur_result_t UR_APICALL urEnqueueMemBufferFill(
 ///         + `region.width == 0 || region.height == 0 || region.depth == 0`
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueMemImageRead(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    ur_mem_handle_t
-        hImage, ///< [in][bounds(origin, region)] handle of the image object
-    bool blockingRead, ///< [in] indicates blocking (true), non-blocking (false)
-    ur_rect_offset_t
-        origin, ///< [in] defines the (x,y,z) offset in pixels in the 1D, 2D, or 3D image
-    ur_rect_region_t
-        region, ///< [in] defines the (width, height, depth) in pixels of the 1D, 2D, or 3D
-                ///< image
-    size_t rowPitch,   ///< [in] length of each row in bytes
-    size_t slicePitch, ///< [in] length of each 2D slice of the 3D image
-    void *pDst, ///< [in] pointer to host memory where image is to be read into
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
-    ///< command does not wait on any event to complete.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueMemImageRead(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    ur_mem_handle_t hImage,                         ///< [in][bounds(origin, region)] handle of the image object
+    bool blockingRead,                              ///< [in] indicates blocking (true), non-blocking (false)
+    ur_rect_offset_t origin,                        ///< [in] defines the (x,y,z) offset in pixels in the 1D, 2D, or 3D image
+    ur_rect_region_t region,                        ///< [in] defines the (width, height, depth) in pixels of the 1D, 2D, or 3D
+                                                    ///< image
+    size_t rowPitch,                                ///< [in] length of each row in bytes
+    size_t slicePitch,                              ///< [in] length of each 2D slice of the 3D image
+    void* pDst,                                     ///< [in] pointer to host memory where image is to be read into
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
+                                                    ///< command does not wait on any event to complete.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -4836,15 +4809,15 @@ ur_result_t UR_APICALL urEnqueueMemImageRead(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to write an image or image array object from host
 ///        memory
-///
+/// 
 /// @details
 ///     - Input parameter blockingWrite indicates if the write is blocking or
 ///       non-blocking.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clEnqueueWriteImage**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -4868,42 +4841,38 @@ ur_result_t UR_APICALL urEnqueueMemImageRead(
 ///         + `region.width == 0 || region.height == 0 || region.depth == 0`
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueMemImageWrite(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    ur_mem_handle_t
-        hImage, ///< [in][bounds(origin, region)] handle of the image object
-    bool
-        blockingWrite, ///< [in] indicates blocking (true), non-blocking (false)
-    ur_rect_offset_t
-        origin, ///< [in] defines the (x,y,z) offset in pixels in the 1D, 2D, or 3D image
-    ur_rect_region_t
-        region, ///< [in] defines the (width, height, depth) in pixels of the 1D, 2D, or 3D
-                ///< image
-    size_t rowPitch,   ///< [in] length of each row in bytes
-    size_t slicePitch, ///< [in] length of each 2D slice of the 3D image
-    void *pSrc, ///< [in] pointer to host memory where image is to be read into
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
-    ///< command does not wait on any event to complete.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueMemImageWrite(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    ur_mem_handle_t hImage,                         ///< [in][bounds(origin, region)] handle of the image object
+    bool blockingWrite,                             ///< [in] indicates blocking (true), non-blocking (false)
+    ur_rect_offset_t origin,                        ///< [in] defines the (x,y,z) offset in pixels in the 1D, 2D, or 3D image
+    ur_rect_region_t region,                        ///< [in] defines the (width, height, depth) in pixels of the 1D, 2D, or 3D
+                                                    ///< image
+    size_t rowPitch,                                ///< [in] length of each row in bytes
+    size_t slicePitch,                              ///< [in] length of each 2D slice of the 3D image
+    void* pSrc,                                     ///< [in] pointer to host memory where image is to be read into
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
+                                                    ///< command does not wait on any event to complete.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to copy from an image object to another
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clEnqueueCopyImage**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -4926,32 +4895,27 @@ ur_result_t UR_APICALL urEnqueueMemImageWrite(
 ///         + `region.width == 0 || region.height == 0 || region.depth == 0`
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueMemImageCopy(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    ur_mem_handle_t
-        hImageSrc, ///< [in][bounds(srcOrigin, region)] handle of the src image object
-    ur_mem_handle_t
-        hImageDst, ///< [in][bounds(dstOrigin, region)] handle of the dest image object
-    ur_rect_offset_t
-        srcOrigin, ///< [in] defines the (x,y,z) offset in pixels in the source 1D, 2D, or 3D
-                   ///< image
-    ur_rect_offset_t
-        dstOrigin, ///< [in] defines the (x,y,z) offset in pixels in the destination 1D, 2D,
-                   ///< or 3D image
-    ur_rect_region_t
-        region, ///< [in] defines the (width, height, depth) in pixels of the 1D, 2D, or 3D
-                ///< image
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
-    ///< command does not wait on any event to complete.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueMemImageCopy(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    ur_mem_handle_t hImageSrc,                      ///< [in][bounds(srcOrigin, region)] handle of the src image object
+    ur_mem_handle_t hImageDst,                      ///< [in][bounds(dstOrigin, region)] handle of the dest image object
+    ur_rect_offset_t srcOrigin,                     ///< [in] defines the (x,y,z) offset in pixels in the source 1D, 2D, or 3D
+                                                    ///< image
+    ur_rect_offset_t dstOrigin,                     ///< [in] defines the (x,y,z) offset in pixels in the destination 1D, 2D,
+                                                    ///< or 3D image
+    ur_rect_region_t region,                        ///< [in] defines the (width, height, depth) in pixels of the 1D, 2D, or 3D
+                                                    ///< image
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
+                                                    ///< command does not wait on any event to complete.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -4959,18 +4923,18 @@ ur_result_t UR_APICALL urEnqueueMemImageCopy(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to map a region of the buffer object into the host
 ///        address space and return a pointer to the mapped region
-///
+/// 
 /// @details
 ///     - Input parameter blockingMap indicates if the map is blocking or
 ///       non-blocking.
 ///     - Currently, no direct support in Level Zero. Implemented as a shared
 ///       allocation followed by copying on discrete GPU
 ///     - TODO: add a driver function in Level Zero?
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clEnqueueMapBuffer**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -4996,27 +4960,26 @@ ur_result_t UR_APICALL urEnqueueMemImageCopy(
 ///         + If `offset + size` results in an out-of-bounds access.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueMemBufferMap(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    ur_mem_handle_t
-        hBuffer, ///< [in][bounds(offset, size)] handle of the buffer object
-    bool blockingMap, ///< [in] indicates blocking (true), non-blocking (false)
-    ur_map_flags_t mapFlags, ///< [in] flags for read, write, readwrite mapping
-    size_t offset, ///< [in] offset in bytes of the buffer region being mapped
-    size_t size,   ///< [in] size in bytes of the buffer region being mapped
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
-    ///< command does not wait on any event to complete.
-    ur_event_handle_t *
-        phEvent, ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-    void **ppRetMap ///< [out] return mapped pointer.  TODO: move it before
-                    ///< numEventsInWaitList?
-) {
+ur_result_t UR_APICALL
+urEnqueueMemBufferMap(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    ur_mem_handle_t hBuffer,                        ///< [in][bounds(offset, size)] handle of the buffer object
+    bool blockingMap,                               ///< [in] indicates blocking (true), non-blocking (false)
+    ur_map_flags_t mapFlags,                        ///< [in] flags for read, write, readwrite mapping
+    size_t offset,                                  ///< [in] offset in bytes of the buffer region being mapped
+    size_t size,                                    ///< [in] size in bytes of the buffer region being mapped
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
+                                                    ///< command does not wait on any event to complete.
+    ur_event_handle_t* phEvent,                     ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    void** ppRetMap                                 ///< [out] return mapped pointer.  TODO: move it before
+                                                    ///< numEventsInWaitList?
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -5024,11 +4987,11 @@ ur_result_t UR_APICALL urEnqueueMemBufferMap(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to unmap a previously mapped region of a memory
 ///        object
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clEnqueueUnmapMemObject**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5050,29 +5013,28 @@ ur_result_t UR_APICALL urEnqueueMemBufferMap(
 ///     - ::UR_RESULT_ERROR_INVALID_MEM_OBJECT
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueMemUnmap(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    ur_mem_handle_t
-        hMem,         ///< [in] handle of the memory (buffer or image) object
-    void *pMappedPtr, ///< [in] mapped host address
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
-    ///< command does not wait on any event to complete.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueMemUnmap(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    ur_mem_handle_t hMem,                           ///< [in] handle of the memory (buffer or image) object
+    void* pMappedPtr,                               ///< [in] mapped host address
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
+                                                    ///< command does not wait on any event to complete.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to fill USM memory.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5099,34 +5061,31 @@ ur_result_t UR_APICALL urEnqueueMemUnmap(
 ///     - ::UR_RESULT_ERROR_INVALID_MEM_OBJECT
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueUSMFill(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    void *pMem, ///< [in][bounds(0, size)] pointer to USM memory object
-    size_t
-        patternSize, ///< [in] the size in bytes of the pattern. Must be a power of 2 and less
-                     ///< than or equal to width.
-    const void
-        *pPattern, ///< [in] pointer with the bytes of the pattern to set.
-    size_t
-        size, ///< [in] size in bytes to be set. Must be a multiple of patternSize.
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
-    ///< command does not wait on any event to complete.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueUSMFill(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    void* pMem,                                     ///< [in][bounds(0, size)] pointer to USM memory object
+    size_t patternSize,                             ///< [in] the size in bytes of the pattern. Must be a power of 2 and less
+                                                    ///< than or equal to width.
+    const void* pPattern,                           ///< [in] pointer with the bytes of the pattern to set.
+    size_t size,                                    ///< [in] size in bytes to be set. Must be a multiple of patternSize.
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
+                                                    ///< command does not wait on any event to complete.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to copy USM memory
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5151,37 +5110,35 @@ ur_result_t UR_APICALL urEnqueueUSMFill(
 ///     - ::UR_RESULT_ERROR_INVALID_MEM_OBJECT
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueUSMMemcpy(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    bool blocking,            ///< [in] blocking or non-blocking copy
-    void *
-        pDst, ///< [in][bounds(0, size)] pointer to the destination USM memory object
-    const void *
-        pSrc, ///< [in][bounds(0, size)] pointer to the source USM memory object
-    size_t size,                  ///< [in] size in bytes to be copied
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
-    ///< command does not wait on any event to complete.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueUSMMemcpy(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    bool blocking,                                  ///< [in] blocking or non-blocking copy
+    void* pDst,                                     ///< [in][bounds(0, size)] pointer to the destination USM memory object
+    const void* pSrc,                               ///< [in][bounds(0, size)] pointer to the source USM memory object
+    size_t size,                                    ///< [in] size in bytes to be copied
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
+                                                    ///< command does not wait on any event to complete.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to prefetch USM memory
-///
+/// 
 /// @details
 ///     - Prefetching may not be supported for all devices or allocation types.
 ///       If memory prefetching is not supported, the prefetch hint will be
 ///       ignored.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5207,35 +5164,34 @@ ur_result_t UR_APICALL urEnqueueUSMMemcpy(
 ///     - ::UR_RESULT_ERROR_INVALID_MEM_OBJECT
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueUSMPrefetch(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    const void
-        *pMem,   ///< [in][bounds(0, size)] pointer to the USM memory object
-    size_t size, ///< [in] size in bytes to be fetched
-    ur_usm_migration_flags_t flags, ///< [in] USM prefetch flags
-    uint32_t numEventsInWaitList,   ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
-    ///< command does not wait on any event to complete.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueUSMPrefetch(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    const void* pMem,                               ///< [in][bounds(0, size)] pointer to the USM memory object
+    size_t size,                                    ///< [in] size in bytes to be fetched
+    ur_usm_migration_flags_t flags,                 ///< [in] USM migration flags
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that this
+                                                    ///< command does not wait on any event to complete.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to set USM memory advice
-///
+/// 
 /// @details
 ///     - Not all memory advice hints may be supported for all devices or
 ///       allocation types. If a memory advice hint is not supported, it will be
 ///       ignored.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5255,23 +5211,23 @@ ur_result_t UR_APICALL urEnqueueUSMPrefetch(
 ///     - ::UR_RESULT_ERROR_INVALID_MEM_OBJECT
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueUSMAdvise(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    const void
-        *pMem,   ///< [in][bounds(0, size)] pointer to the USM memory object
-    size_t size, ///< [in] size in bytes to be advised
-    ur_usm_advice_flags_t advice, ///< [in] USM memory advice
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-                ///< command instance.
-) {
+ur_result_t UR_APICALL
+urEnqueueUSMAdvise(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    const void* pMem,                               ///< [in][bounds(0, size)] pointer to the USM memory object
+    size_t size,                                    ///< [in] size in bytes to be advised
+    ur_usm_advice_flags_t advice,                   ///< [in] USM memory advice
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to fill 2D USM memory.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5302,38 +5258,33 @@ ur_result_t UR_APICALL urEnqueueUSMAdvise(
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
-ur_result_t UR_APICALL urEnqueueUSMFill2D(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue to submit to.
-    void *
-        pMem, ///< [in][bounds(0, pitch * height)] pointer to memory to be filled.
-    size_t
-        pitch, ///< [in] the total width of the destination memory including padding.
-    size_t
-        patternSize, ///< [in] the size in bytes of the pattern. Must be a power of 2 and less
-                     ///< than or equal to width.
-    const void
-        *pPattern, ///< [in] pointer with the bytes of the pattern to set.
-    size_t
-        width, ///< [in] the width in bytes of each row to fill. Must be a multiple of
-               ///< patternSize.
-    size_t height,                ///< [in] the height of the columns to fill.
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the kernel execution.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that no wait event.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< kernel execution instance. If phEventWaitList and phEvent are not
-    ///< NULL, phEvent must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueUSMFill2D(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue to submit to.
+    void* pMem,                                     ///< [in][bounds(0, pitch * height)] pointer to memory to be filled.
+    size_t pitch,                                   ///< [in] the total width of the destination memory including padding.
+    size_t patternSize,                             ///< [in] the size in bytes of the pattern. Must be a power of 2 and less
+                                                    ///< than or equal to width.
+    const void* pPattern,                           ///< [in] pointer with the bytes of the pattern to set.
+    size_t width,                                   ///< [in] the width in bytes of each row to fill. Must be a multiple of
+                                                    ///< patternSize.
+    size_t height,                                  ///< [in] the height of the columns to fill.
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the kernel execution.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that no wait event.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< kernel execution instance. If phEventWaitList and phEvent are not
+                                                    ///< NULL, phEvent must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to copy 2D USM memory.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5362,30 +5313,26 @@ ur_result_t UR_APICALL urEnqueueUSMFill2D(
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_FEATURE
-ur_result_t UR_APICALL urEnqueueUSMMemcpy2D(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue to submit to.
-    bool blocking, ///< [in] indicates if this operation should block the host.
-    void *
-        pDst, ///< [in][bounds(0, dstPitch * height)] pointer to memory where data will
-              ///< be copied.
-    size_t
-        dstPitch, ///< [in] the total width of the source memory including padding.
-    const void *
-        pSrc, ///< [in][bounds(0, srcPitch * height)] pointer to memory to be copied.
-    size_t
-        srcPitch, ///< [in] the total width of the source memory including padding.
-    size_t width,  ///< [in] the width in bytes of each row to be copied.
-    size_t height, ///< [in] the height of columns to be copied.
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the kernel execution.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that no wait event.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< kernel execution instance. If phEventWaitList and phEvent are not
-    ///< NULL, phEvent must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueUSMMemcpy2D(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue to submit to.
+    bool blocking,                                  ///< [in] indicates if this operation should block the host.
+    void* pDst,                                     ///< [in][bounds(0, dstPitch * height)] pointer to memory where data will
+                                                    ///< be copied.
+    size_t dstPitch,                                ///< [in] the total width of the source memory including padding.
+    const void* pSrc,                               ///< [in][bounds(0, srcPitch * height)] pointer to memory to be copied.
+    size_t srcPitch,                                ///< [in] the total width of the source memory including padding.
+    size_t width,                                   ///< [in] the width in bytes of each row to be copied.
+    size_t height,                                  ///< [in] the height of columns to be copied.
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the kernel execution.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that no wait event.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< kernel execution instance. If phEventWaitList and phEvent are not
+                                                    ///< NULL, phEvent must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -5393,7 +5340,7 @@ ur_result_t UR_APICALL urEnqueueUSMMemcpy2D(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to write data from the host to device global
 ///        variable.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5411,27 +5358,24 @@ ur_result_t UR_APICALL urEnqueueUSMMemcpy2D(
 ///         + If event objects in phEventWaitList are not valid events.
 ///     - ::UR_RESULT_ERROR_IN_EVENT_LIST_EXEC_STATUS
 ///         + An event in `phEventWaitList` has ::UR_EVENT_STATUS_ERROR.
-ur_result_t UR_APICALL urEnqueueDeviceGlobalVariableWrite(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue to submit to.
-    ur_program_handle_t
-        hProgram, ///< [in] handle of the program containing the device global variable.
-    const char
-        *name, ///< [in] the unique identifier for the device global variable.
-    bool blockingWrite, ///< [in] indicates if this operation should block.
-    size_t count,       ///< [in] the number of bytes to copy.
-    size_t
-        offset, ///< [in] the byte offset into the device global variable to start copying.
-    const void *pSrc, ///< [in] pointer to where the data must be copied from.
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list.
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the kernel execution.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that no wait event.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< kernel execution instance. If phEventWaitList and phEvent are not
-    ///< NULL, phEvent must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueDeviceGlobalVariableWrite(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue to submit to.
+    ur_program_handle_t hProgram,                   ///< [in] handle of the program containing the device global variable.
+    const char* name,                               ///< [in] the unique identifier for the device global variable.
+    bool blockingWrite,                             ///< [in] indicates if this operation should block.
+    size_t count,                                   ///< [in] the number of bytes to copy.
+    size_t offset,                                  ///< [in] the byte offset into the device global variable to start copying.
+    const void* pSrc,                               ///< [in] pointer to where the data must be copied from.
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list.
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the kernel execution.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that no wait event.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< kernel execution instance. If phEventWaitList and phEvent are not
+                                                    ///< NULL, phEvent must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -5439,7 +5383,7 @@ ur_result_t UR_APICALL urEnqueueDeviceGlobalVariableWrite(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to read data from a device global variable to the
 ///        host.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5457,34 +5401,31 @@ ur_result_t UR_APICALL urEnqueueDeviceGlobalVariableWrite(
 ///         + If event objects in phEventWaitList are not valid events.
 ///     - ::UR_RESULT_ERROR_IN_EVENT_LIST_EXEC_STATUS
 ///         + An event in `phEventWaitList` has ::UR_EVENT_STATUS_ERROR.
-ur_result_t UR_APICALL urEnqueueDeviceGlobalVariableRead(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue to submit to.
-    ur_program_handle_t
-        hProgram, ///< [in] handle of the program containing the device global variable.
-    const char
-        *name, ///< [in] the unique identifier for the device global variable.
-    bool blockingRead, ///< [in] indicates if this operation should block.
-    size_t count,      ///< [in] the number of bytes to copy.
-    size_t
-        offset, ///< [in] the byte offset into the device global variable to start copying.
-    void *pDst, ///< [in] pointer to where the data must be copied to.
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list.
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the kernel execution.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that no wait event.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< kernel execution instance. If phEventWaitList and phEvent are not
-    ///< NULL, phEvent must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueDeviceGlobalVariableRead(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue to submit to.
+    ur_program_handle_t hProgram,                   ///< [in] handle of the program containing the device global variable.
+    const char* name,                               ///< [in] the unique identifier for the device global variable.
+    bool blockingRead,                              ///< [in] indicates if this operation should block.
+    size_t count,                                   ///< [in] the number of bytes to copy.
+    size_t offset,                                  ///< [in] the byte offset into the device global variable to start copying.
+    void* pDst,                                     ///< [in] pointer to where the data must be copied to.
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list.
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the kernel execution.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that no wait event.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< kernel execution instance. If phEventWaitList and phEvent are not
+                                                    ///< NULL, phEvent must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to read from a pipe to the host.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5502,39 +5443,34 @@ ur_result_t UR_APICALL urEnqueueDeviceGlobalVariableRead(
 ///         + If event objects in phEventWaitList are not valid events.
 ///     - ::UR_RESULT_ERROR_IN_EVENT_LIST_EXEC_STATUS
 ///         + An event in `phEventWaitList` has ::UR_EVENT_STATUS_ERROR.
-ur_result_t UR_APICALL urEnqueueReadHostPipe(
-    ur_queue_handle_t
-        hQueue, ///< [in] a valid host command-queue in which the read command
-    ///< will be queued. hQueue and hProgram must be created with the same
-    ///< UR context.
-    ur_program_handle_t
-        hProgram, ///< [in] a program object with a successfully built executable.
-    const char *
-        pipe_symbol, ///< [in] the name of the program scope pipe global variable.
-    bool
-        blocking, ///< [in] indicate if the read operation is blocking or non-blocking.
-    void *
-        pDst, ///< [in] a pointer to buffer in host memory that will hold resulting data
-              ///< from pipe.
-    size_t size, ///< [in] size of the memory region to read, in bytes.
-    uint32_t numEventsInWaitList, ///< [in] number of events in the wait list.
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the host pipe read.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that no wait event.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] returns an event object that identifies this read command
-    ///< and can be used to query or queue a wait for this command to complete.
-    ///< If phEventWaitList and phEvent are not NULL, phEvent must not refer to
-    ///< an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueReadHostPipe(
+    ur_queue_handle_t hQueue,                       ///< [in] a valid host command-queue in which the read command
+                                                    ///< will be queued. hQueue and hProgram must be created with the same
+                                                    ///< UR context.
+    ur_program_handle_t hProgram,                   ///< [in] a program object with a successfully built executable.
+    const char* pipe_symbol,                        ///< [in] the name of the program scope pipe global variable.
+    bool blocking,                                  ///< [in] indicate if the read operation is blocking or non-blocking.
+    void* pDst,                                     ///< [in] a pointer to buffer in host memory that will hold resulting data
+                                                    ///< from pipe.
+    size_t size,                                    ///< [in] size of the memory region to read, in bytes.
+    uint32_t numEventsInWaitList,                   ///< [in] number of events in the wait list.
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the host pipe read.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that no wait event.
+    ur_event_handle_t* phEvent                      ///< [out][optional] returns an event object that identifies this read command
+                                                    ///< and can be used to query or queue a wait for this command to complete.
+                                                    ///< If phEventWaitList and phEvent are not NULL, phEvent must not refer to
+                                                    ///< an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to write data from the host to a pipe.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5552,40 +5488,35 @@ ur_result_t UR_APICALL urEnqueueReadHostPipe(
 ///         + If event objects in phEventWaitList are not valid events.
 ///     - ::UR_RESULT_ERROR_IN_EVENT_LIST_EXEC_STATUS
 ///         + An event in `phEventWaitList` has ::UR_EVENT_STATUS_ERROR.
-ur_result_t UR_APICALL urEnqueueWriteHostPipe(
-    ur_queue_handle_t
-        hQueue, ///< [in] a valid host command-queue in which the write command
-    ///< will be queued. hQueue and hProgram must be created with the same
-    ///< UR context.
-    ur_program_handle_t
-        hProgram, ///< [in] a program object with a successfully built executable.
-    const char *
-        pipe_symbol, ///< [in] the name of the program scope pipe global variable.
-    bool
-        blocking, ///< [in] indicate if the read and write operations are blocking or
-                  ///< non-blocking.
-    void *
-        pSrc, ///< [in] a pointer to buffer in host memory that holds data to be written
-              ///< to the host pipe.
-    size_t size, ///< [in] size of the memory region to read or write, in bytes.
-    uint32_t numEventsInWaitList, ///< [in] number of events in the wait list.
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the host pipe write.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that no wait event.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] returns an event object that identifies this write command
-    ///< and can be used to query or queue a wait for this command to complete.
-    ///< If phEventWaitList and phEvent are not NULL, phEvent must not refer to
-    ///< an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueWriteHostPipe(
+    ur_queue_handle_t hQueue,                       ///< [in] a valid host command-queue in which the write command
+                                                    ///< will be queued. hQueue and hProgram must be created with the same
+                                                    ///< UR context.
+    ur_program_handle_t hProgram,                   ///< [in] a program object with a successfully built executable.
+    const char* pipe_symbol,                        ///< [in] the name of the program scope pipe global variable.
+    bool blocking,                                  ///< [in] indicate if the read and write operations are blocking or
+                                                    ///< non-blocking.
+    void* pSrc,                                     ///< [in] a pointer to buffer in host memory that holds data to be written
+                                                    ///< to the host pipe.
+    size_t size,                                    ///< [in] size of the memory region to read or write, in bytes.
+    uint32_t numEventsInWaitList,                   ///< [in] number of events in the wait list.
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the host pipe write.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that no wait event.
+    ur_event_handle_t* phEvent                      ///< [out][optional] returns an event object that identifies this write command
+                                                    ///< and can be used to query or queue a wait for this command to complete.
+                                                    ///< If phEventWaitList and phEvent are not NULL, phEvent must not refer to
+                                                    ///< an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief USM allocate pitched memory
-///
+/// 
 /// @details
 ///     - This function must support memory pooling.
 ///     - If pUSMDesc is not NULL and pUSMDesc->pool is not NULL the allocation
@@ -5597,11 +5528,11 @@ ur_result_t UR_APICALL urEnqueueWriteHostPipe(
 ///       allocation.
 ///     - See also ::ur_usm_host_desc_t.
 ///     - See also ::ur_usm_device_desc_t.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **cuMemAllocPitch**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5626,32 +5557,30 @@ ur_result_t UR_APICALL urEnqueueWriteHostPipe(
 ///         + If `UR_DEVICE_INFO_USM_SINGLE_SHARED_SUPPORT` and `UR_DEVICE_INFO_USM_CROSS_SHARED_SUPPORT` are both false.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urUSMPitchedAllocExp(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_device_handle_t hDevice,   ///< [in] handle of the device object
-    const ur_usm_desc_t *
-        pUSMDesc, ///< [in][optional] Pointer to USM memory allocation descriptor.
-    ur_usm_pool_handle_t
-        pool, ///< [in][optional] Pointer to a pool created using urUSMPoolCreate
-    size_t
-        widthInBytes, ///< [in] width in bytes of the USM memory object to be allocated
-    size_t height, ///< [in] height of the USM memory object to be allocated
-    size_t
-        elementSizeBytes, ///< [in] size in bytes of an element in the allocation
-    void **ppMem,         ///< [out] pointer to USM shared memory object
-    size_t *pResultPitch  ///< [out] pitch of the allocation
-) {
+ur_result_t UR_APICALL
+urUSMPitchedAllocExp(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device object
+    const ur_usm_desc_t* pUSMDesc,                  ///< [in][optional] Pointer to USM memory allocation descriptor.
+    ur_usm_pool_handle_t pool,                      ///< [in][optional] Pointer to a pool created using urUSMPoolCreate
+    size_t widthInBytes,                            ///< [in] width in bytes of the USM memory object to be allocated
+    size_t height,                                  ///< [in] height of the USM memory object to be allocated
+    size_t elementSizeBytes,                        ///< [in] size in bytes of an element in the allocation
+    void** ppMem,                                   ///< [out] pointer to USM shared memory object
+    size_t* pResultPitch                            ///< [out] pitch of the allocation
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Destroy bindless unsampled image handles
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **cuSurfObjectDestroy**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5662,23 +5591,24 @@ ur_result_t UR_APICALL urUSMPitchedAllocExp(
 ///         + `NULL == hDevice`
 ///     - ::UR_RESULT_ERROR_INVALID_CONTEXT
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
-ur_result_t UR_APICALL urBindlessImagesUnsampledImageHandleDestroyExp(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_device_handle_t hDevice,   ///< [in] handle of the device object
-    ur_exp_image_native_handle_t
-        hImage ///< [in][release] pointer to handle of image object to destroy
-) {
+ur_result_t UR_APICALL
+urBindlessImagesUnsampledImageHandleDestroyExp(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device object
+    ur_exp_image_native_handle_t hImage             ///< [in][release] pointer to handle of image object to destroy
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Destroy bindless sampled image handles
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **cuTexObjectDestroy**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5689,24 +5619,25 @@ ur_result_t UR_APICALL urBindlessImagesUnsampledImageHandleDestroyExp(
 ///         + `NULL == hDevice`
 ///     - ::UR_RESULT_ERROR_INVALID_CONTEXT
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
-ur_result_t UR_APICALL urBindlessImagesSampledImageHandleDestroyExp(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_device_handle_t hDevice,   ///< [in] handle of the device object
-    ur_exp_image_native_handle_t
-        hImage ///< [in][release] pointer to handle of image object to destroy
-) {
+ur_result_t UR_APICALL
+urBindlessImagesSampledImageHandleDestroyExp(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device object
+    ur_exp_image_native_handle_t hImage             ///< [in][release] pointer to handle of image object to destroy
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Allocate memory for bindless images
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **cuArray3DCreate**
 ///     - **cuMipmappedArrayCreate**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5725,26 +5656,26 @@ ur_result_t UR_APICALL urBindlessImagesSampledImageHandleDestroyExp(
 ///         + `pImageDesc && UR_MEM_TYPE_IMAGE_CUBEMAP_EXP < pImageDesc->type`
 ///     - ::UR_RESULT_ERROR_INVALID_IMAGE_SIZE
 ///     - ::UR_RESULT_ERROR_INVALID_OPERATION
-ur_result_t UR_APICALL urBindlessImagesImageAllocateExp(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_device_handle_t hDevice,   ///< [in] handle of the device object
-    const ur_image_format_t
-        *pImageFormat, ///< [in] pointer to image format specification
-    const ur_image_desc_t *pImageDesc, ///< [in] pointer to image description
-    ur_exp_image_mem_native_handle_t
-        *phImageMem ///< [out] pointer to handle of image memory allocated
-) {
+ur_result_t UR_APICALL
+urBindlessImagesImageAllocateExp(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device object
+    const ur_image_format_t* pImageFormat,          ///< [in] pointer to image format specification
+    const ur_image_desc_t* pImageDesc,              ///< [in] pointer to image description
+    ur_exp_image_mem_native_handle_t* phImageMem    ///< [out] pointer to handle of image memory allocated
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Free memory for bindless images
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **cuArrayDestroy**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5755,23 +5686,24 @@ ur_result_t UR_APICALL urBindlessImagesImageAllocateExp(
 ///         + `NULL == hDevice`
 ///     - ::UR_RESULT_ERROR_INVALID_CONTEXT
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
-ur_result_t UR_APICALL urBindlessImagesImageFreeExp(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_device_handle_t hDevice,   ///< [in] handle of the device object
-    ur_exp_image_mem_native_handle_t
-        hImageMem ///< [in][release] handle of image memory to be freed
-) {
+ur_result_t UR_APICALL
+urBindlessImagesImageFreeExp(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device object
+    ur_exp_image_mem_native_handle_t hImageMem      ///< [in][release] handle of image memory to be freed
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create a bindless unsampled image handle
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **cuSurfObjectCreate**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5791,28 +5723,27 @@ ur_result_t UR_APICALL urBindlessImagesImageFreeExp(
 ///     - ::UR_RESULT_ERROR_INVALID_IMAGE_SIZE
 ///     - ::UR_RESULT_ERROR_INVALID_OPERATION
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
-ur_result_t UR_APICALL urBindlessImagesUnsampledImageCreateExp(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_device_handle_t hDevice,   ///< [in] handle of the device object
-    ur_exp_image_mem_native_handle_t
-        hImageMem, ///< [in] handle to memory from which to create the image
-    const ur_image_format_t
-        *pImageFormat, ///< [in] pointer to image format specification
-    const ur_image_desc_t *pImageDesc, ///< [in] pointer to image description
-    ur_exp_image_native_handle_t
-        *phImage ///< [out] pointer to handle of image object created
-) {
+ur_result_t UR_APICALL
+urBindlessImagesUnsampledImageCreateExp(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device object
+    ur_exp_image_mem_native_handle_t hImageMem,     ///< [in] handle to memory from which to create the image
+    const ur_image_format_t* pImageFormat,          ///< [in] pointer to image format specification
+    const ur_image_desc_t* pImageDesc,              ///< [in] pointer to image description
+    ur_exp_image_native_handle_t* phImage           ///< [out] pointer to handle of image object created
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create a bindless sampled image handle
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **cuTexObjectCreate**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5834,32 +5765,31 @@ ur_result_t UR_APICALL urBindlessImagesUnsampledImageCreateExp(
 ///     - ::UR_RESULT_ERROR_INVALID_SAMPLER
 ///     - ::UR_RESULT_ERROR_INVALID_OPERATION
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
-ur_result_t UR_APICALL urBindlessImagesSampledImageCreateExp(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_device_handle_t hDevice,   ///< [in] handle of the device object
-    ur_exp_image_mem_native_handle_t
-        hImageMem, ///< [in] handle to memory from which to create the image
-    const ur_image_format_t
-        *pImageFormat, ///< [in] pointer to image format specification
-    const ur_image_desc_t *pImageDesc, ///< [in] pointer to image description
-    ur_sampler_handle_t hSampler,      ///< [in] sampler to be used
-    ur_exp_image_native_handle_t
-        *phImage ///< [out] pointer to handle of image object created
-) {
+ur_result_t UR_APICALL
+urBindlessImagesSampledImageCreateExp(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device object
+    ur_exp_image_mem_native_handle_t hImageMem,     ///< [in] handle to memory from which to create the image
+    const ur_image_format_t* pImageFormat,          ///< [in] pointer to image format specification
+    const ur_image_desc_t* pImageDesc,              ///< [in] pointer to image description
+    ur_sampler_handle_t hSampler,                   ///< [in] sampler to be used
+    ur_exp_image_native_handle_t* phImage           ///< [out] pointer to handle of image object created
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Copy image data Host to Device, Device to Host, or Device to Device
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **cuMemcpyHtoAAsync**
 ///     - **cuMemcpyAtoHAsync**
 ///     - **cuMemcpy2DAsync**
 ///     - **cuMemcpy3DAsync**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5884,40 +5814,36 @@ ur_result_t UR_APICALL urBindlessImagesSampledImageCreateExp(
 ///         + `pDstImageDesc && UR_MEM_TYPE_IMAGE_CUBEMAP_EXP < pDstImageDesc->type`
 ///     - ::UR_RESULT_ERROR_INVALID_IMAGE_SIZE
 ///     - ::UR_RESULT_ERROR_INVALID_OPERATION
-ur_result_t UR_APICALL urBindlessImagesImageCopyExp(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    const void *pSrc,         ///< [in] location the data will be copied from
-    void *pDst,               ///< [in] location the data will be copied to
-    const ur_image_desc_t *pSrcImageDesc, ///< [in] pointer to image description
-    const ur_image_desc_t *pDstImageDesc, ///< [in] pointer to image description
-    const ur_image_format_t
-        *pSrcImageFormat, ///< [in] pointer to image format specification
-    const ur_image_format_t
-        *pDstImageFormat, ///< [in] pointer to image format specification
-    ur_exp_image_copy_region_t *
-        pCopyRegion, ///< [in] Pointer to structure describing the (sub-)regions of source and
-                     ///< destination images
-    ur_exp_image_copy_flags_t
-        imageCopyFlags, ///< [in] flags describing copy direction e.g. H2D or D2H
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that all
-    ///< previously enqueued commands
-    ///< must be complete.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urBindlessImagesImageCopyExp(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    const void* pSrc,                               ///< [in] location the data will be copied from
+    void* pDst,                                     ///< [in] location the data will be copied to
+    const ur_image_desc_t* pSrcImageDesc,           ///< [in] pointer to image description
+    const ur_image_desc_t* pDstImageDesc,           ///< [in] pointer to image description
+    const ur_image_format_t* pSrcImageFormat,       ///< [in] pointer to image format specification
+    const ur_image_format_t* pDstImageFormat,       ///< [in] pointer to image format specification
+    ur_exp_image_copy_region_t* pCopyRegion,        ///< [in] Pointer to structure describing the (sub-)regions of source and
+                                                    ///< destination images
+    ur_exp_image_copy_flags_t imageCopyFlags,       ///< [in] flags describing copy direction e.g. H2D or D2H
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that all
+                                                    ///< previously enqueued commands
+                                                    ///< must be complete.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Query an image memory handle for specific properties
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5936,25 +5862,26 @@ ur_result_t UR_APICALL urBindlessImagesImageCopyExp(
 ///     - ::UR_RESULT_ERROR_INVALID_DEVICE
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urBindlessImagesImageGetInfoExp(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_exp_image_mem_native_handle_t
-        hImageMem,            ///< [in] handle to the image memory
-    ur_image_info_t propName, ///< [in] queried info name
-    void *pPropValue,         ///< [out][optional] returned query value
-    size_t *pPropSizeRet      ///< [out][optional] returned query value size
-) {
+ur_result_t UR_APICALL
+urBindlessImagesImageGetInfoExp(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_exp_image_mem_native_handle_t hImageMem,     ///< [in] handle to the image memory
+    ur_image_info_t propName,                       ///< [in] queried info name
+    void* pPropValue,                               ///< [out][optional] returned query value
+    size_t* pPropSizeRet                            ///< [out][optional] returned query value size
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Retrieve individual image from mipmap
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **cuMipmappedArrayGetLevel**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5967,26 +5894,26 @@ ur_result_t UR_APICALL urBindlessImagesImageGetInfoExp(
 ///         + `NULL == phImageMem`
 ///     - ::UR_RESULT_ERROR_INVALID_CONTEXT
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
-ur_result_t UR_APICALL urBindlessImagesMipmapGetLevelExp(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_device_handle_t hDevice,   ///< [in] handle of the device object
-    ur_exp_image_mem_native_handle_t
-        hImageMem,        ///< [in] memory handle to the mipmap image
-    uint32_t mipmapLevel, ///< [in] requested level of the mipmap
-    ur_exp_image_mem_native_handle_t
-        *phImageMem ///< [out] returning memory handle to the individual image
-) {
+ur_result_t UR_APICALL
+urBindlessImagesMipmapGetLevelExp(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device object
+    ur_exp_image_mem_native_handle_t hImageMem,     ///< [in] memory handle to the mipmap image
+    uint32_t mipmapLevel,                           ///< [in] requested level of the mipmap
+    ur_exp_image_mem_native_handle_t* phImageMem    ///< [out] returning memory handle to the individual image
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Free mipmap memory for bindless images
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **cuMipmappedArrayDestroy**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -5997,23 +5924,24 @@ ur_result_t UR_APICALL urBindlessImagesMipmapGetLevelExp(
 ///         + `NULL == hDevice`
 ///     - ::UR_RESULT_ERROR_INVALID_CONTEXT
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
-ur_result_t UR_APICALL urBindlessImagesMipmapFreeExp(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_device_handle_t hDevice,   ///< [in] handle of the device object
-    ur_exp_image_mem_native_handle_t
-        hMem ///< [in][release] handle of image memory to be freed
-) {
+ur_result_t UR_APICALL
+urBindlessImagesMipmapFreeExp(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device object
+    ur_exp_image_mem_native_handle_t hMem           ///< [in][release] handle of image memory to be freed
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Import external memory
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **cuImportExternalMemory**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6030,24 +5958,23 @@ ur_result_t UR_APICALL urBindlessImagesMipmapFreeExp(
 ///     - ::UR_RESULT_ERROR_INVALID_CONTEXT
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
 ///     - ::UR_RESULT_ERROR_INVALID_MEM_OBJECT
-ur_result_t UR_APICALL urBindlessImagesImportExternalMemoryExp(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_device_handle_t hDevice,   ///< [in] handle of the device object
-    size_t size,                  ///< [in] size of the external memory
-    ur_exp_external_mem_type_t
-        memHandleType, ///< [in] type of external memory handle
-    ur_exp_external_mem_desc_t
-        *pExternalMemDesc, ///< [in] the external memory descriptor
-    ur_exp_external_mem_handle_t
-        *phExternalMem ///< [out] external memory handle to the external memory
-) {
+ur_result_t UR_APICALL
+urBindlessImagesImportExternalMemoryExp(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device object
+    size_t size,                                    ///< [in] size of the external memory
+    ur_exp_external_mem_type_t memHandleType,       ///< [in] type of external memory handle
+    ur_exp_external_mem_desc_t* pExternalMemDesc,   ///< [in] the external memory descriptor
+    ur_exp_external_mem_handle_t* phExternalMem     ///< [out] external memory handle to the external memory
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Map an external memory handle to an image memory handle
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6068,17 +5995,16 @@ ur_result_t UR_APICALL urBindlessImagesImportExternalMemoryExp(
 ///     - ::UR_RESULT_ERROR_INVALID_IMAGE_SIZE
 ///     - ::UR_RESULT_ERROR_INVALID_OPERATION
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urBindlessImagesMapExternalArrayExp(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_device_handle_t hDevice,   ///< [in] handle of the device object
-    const ur_image_format_t
-        *pImageFormat, ///< [in] pointer to image format specification
-    const ur_image_desc_t *pImageDesc, ///< [in] pointer to image description
-    ur_exp_external_mem_handle_t
-        hExternalMem, ///< [in] external memory handle to the external memory
-    ur_exp_image_mem_native_handle_t *
-        phImageMem ///< [out] image memory handle to the externally allocated memory
-) {
+ur_result_t UR_APICALL
+urBindlessImagesMapExternalArrayExp(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device object
+    const ur_image_format_t* pImageFormat,          ///< [in] pointer to image format specification
+    const ur_image_desc_t* pImageDesc,              ///< [in] pointer to image description
+    ur_exp_external_mem_handle_t hExternalMem,      ///< [in] external memory handle to the external memory
+    ur_exp_image_mem_native_handle_t* phImageMem    ///< [out] image memory handle to the externally allocated memory
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -6086,7 +6012,7 @@ ur_result_t UR_APICALL urBindlessImagesMapExternalArrayExp(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Map an external memory handle to a device memory region described by
 ///        void*
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6103,26 +6029,27 @@ ur_result_t UR_APICALL urBindlessImagesMapExternalArrayExp(
 ///     - ::UR_RESULT_ERROR_INVALID_IMAGE_SIZE
 ///     - ::UR_RESULT_ERROR_INVALID_OPERATION
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urBindlessImagesMapExternalLinearMemoryExp(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_device_handle_t hDevice,   ///< [in] handle of the device object
-    uint64_t offset,              ///< [in] offset into memory region to map
-    uint64_t size,                ///< [in] size of memory region to map
-    ur_exp_external_mem_handle_t
-        hExternalMem, ///< [in] external memory handle to the external memory
-    void **ppRetMem   ///< [out] pointer of the externally allocated memory
-) {
+ur_result_t UR_APICALL
+urBindlessImagesMapExternalLinearMemoryExp(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device object
+    uint64_t offset,                                ///< [in] offset into memory region to map
+    uint64_t size,                                  ///< [in] size of memory region to map
+    ur_exp_external_mem_handle_t hExternalMem,      ///< [in] external memory handle to the external memory
+    void** ppRetMem                                 ///< [out] pointer of the externally allocated memory
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Release external memory
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **cuDestroyExternalMemory**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6134,23 +6061,24 @@ ur_result_t UR_APICALL urBindlessImagesMapExternalLinearMemoryExp(
 ///         + `NULL == hExternalMem`
 ///     - ::UR_RESULT_ERROR_INVALID_CONTEXT
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
-ur_result_t UR_APICALL urBindlessImagesReleaseExternalMemoryExp(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_device_handle_t hDevice,   ///< [in] handle of the device object
-    ur_exp_external_mem_handle_t
-        hExternalMem ///< [in][release] handle of external memory to be destroyed
-) {
+ur_result_t UR_APICALL
+urBindlessImagesReleaseExternalMemoryExp(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device object
+    ur_exp_external_mem_handle_t hExternalMem       ///< [in][release] handle of external memory to be destroyed
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Import an external semaphore
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **cuImportExternalSemaphore**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6166,27 +6094,26 @@ ur_result_t UR_APICALL urBindlessImagesReleaseExternalMemoryExp(
 ///         + `NULL == phExternalSemaphore`
 ///     - ::UR_RESULT_ERROR_INVALID_CONTEXT
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
-ur_result_t UR_APICALL urBindlessImagesImportExternalSemaphoreExp(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_device_handle_t hDevice,   ///< [in] handle of the device object
-    ur_exp_external_semaphore_type_t
-        semHandleType, ///< [in] type of external memory handle
-    ur_exp_external_semaphore_desc_t
-        *pExternalSemaphoreDesc, ///< [in] the external semaphore descriptor
-    ur_exp_external_semaphore_handle_t *
-        phExternalSemaphore ///< [out] external semaphore handle to the external semaphore
-) {
+ur_result_t UR_APICALL
+urBindlessImagesImportExternalSemaphoreExp(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device object
+    ur_exp_external_semaphore_type_t semHandleType, ///< [in] type of external memory handle
+    ur_exp_external_semaphore_desc_t* pExternalSemaphoreDesc,   ///< [in] the external semaphore descriptor
+    ur_exp_external_semaphore_handle_t* phExternalSemaphore ///< [out] external semaphore handle to the external semaphore
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Release the external semaphore
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **cuDestroyExternalSemaphore**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6198,23 +6125,24 @@ ur_result_t UR_APICALL urBindlessImagesImportExternalSemaphoreExp(
 ///         + `NULL == hExternalSemaphore`
 ///     - ::UR_RESULT_ERROR_INVALID_CONTEXT
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
-ur_result_t UR_APICALL urBindlessImagesReleaseExternalSemaphoreExp(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    ur_device_handle_t hDevice,   ///< [in] handle of the device object
-    ur_exp_external_semaphore_handle_t
-        hExternalSemaphore ///< [in][release] handle of external semaphore to be destroyed
-) {
+ur_result_t UR_APICALL
+urBindlessImagesReleaseExternalSemaphoreExp(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    ur_device_handle_t hDevice,                     ///< [in] handle of the device object
+    ur_exp_external_semaphore_handle_t hExternalSemaphore   ///< [in][release] handle of external semaphore to be destroyed
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Instruct the queue with a non-blocking wait on an external semaphore
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **cuWaitExternalSemaphoresAsync**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6225,28 +6153,26 @@ ur_result_t UR_APICALL urBindlessImagesReleaseExternalSemaphoreExp(
 ///         + `NULL == hSemaphore`
 ///     - ::UR_RESULT_ERROR_INVALID_QUEUE
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
-ur_result_t UR_APICALL urBindlessImagesWaitExternalSemaphoreExp(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    ur_exp_external_semaphore_handle_t
-        hSemaphore, ///< [in] external semaphore handle
-    bool
-        hasWaitValue, ///< [in] indicates whether the samephore is capable and should wait on a
-                      ///< certain value.
-    ///< Otherwise the semaphore is treated like a binary state, and
-    ///< `waitValue` is ignored.
-    uint64_t waitValue,           ///< [in] the value to be waited on
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that all
-    ///< previously enqueued commands
-    ///< must be complete.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urBindlessImagesWaitExternalSemaphoreExp(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    ur_exp_external_semaphore_handle_t hSemaphore,  ///< [in] external semaphore handle
+    bool hasWaitValue,                              ///< [in] indicates whether the samephore is capable and should wait on a
+                                                    ///< certain value.
+                                                    ///< Otherwise the semaphore is treated like a binary state, and
+                                                    ///< `waitValue` is ignored.
+    uint64_t waitValue,                             ///< [in] the value to be waited on
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that all
+                                                    ///< previously enqueued commands
+                                                    ///< must be complete.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -6254,11 +6180,11 @@ ur_result_t UR_APICALL urBindlessImagesWaitExternalSemaphoreExp(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Instruct the queue to signal the external semaphore handle once all
 ///        previous commands have completed execution
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **cuSignalExternalSemaphoresAsync**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6269,38 +6195,36 @@ ur_result_t UR_APICALL urBindlessImagesWaitExternalSemaphoreExp(
 ///         + `NULL == hSemaphore`
 ///     - ::UR_RESULT_ERROR_INVALID_QUEUE
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
-ur_result_t UR_APICALL urBindlessImagesSignalExternalSemaphoreExp(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    ur_exp_external_semaphore_handle_t
-        hSemaphore, ///< [in] external semaphore handle
-    bool
-        hasSignalValue, ///< [in] indicates whether the samephore is capable and should signal on a
-                        ///< certain value.
-    ///< Otherwise the semaphore is treated like a binary state, and
-    ///< `signalValue` is ignored.
-    uint64_t signalValue,         ///< [in] the value to be signalled
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that all
-    ///< previously enqueued commands
-    ///< must be complete.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urBindlessImagesSignalExternalSemaphoreExp(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    ur_exp_external_semaphore_handle_t hSemaphore,  ///< [in] external semaphore handle
+    bool hasSignalValue,                            ///< [in] indicates whether the samephore is capable and should signal on a
+                                                    ///< certain value.
+                                                    ///< Otherwise the semaphore is treated like a binary state, and
+                                                    ///< `signalValue` is ignored.
+    uint64_t signalValue,                           ///< [in] the value to be signalled
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that all
+                                                    ///< previously enqueued commands
+                                                    ///< must be complete.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Create a Command-Buffer object
-///
+/// 
 /// @details
 ///     - Create a command-buffer object.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6317,21 +6241,21 @@ ur_result_t UR_APICALL urBindlessImagesSignalExternalSemaphoreExp(
 ///         + If `pCommandBufferDesc->isUpdatable` is true and `hDevice` does not support UR_DEVICE_INFO_COMMAND_BUFFER_UPDATE_SUPPORT_EXP.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urCommandBufferCreateExp(
-    ur_context_handle_t hContext, ///< [in] Handle of the context object.
-    ur_device_handle_t hDevice,   ///< [in] Handle of the device object.
-    const ur_exp_command_buffer_desc_t
-        *pCommandBufferDesc, ///< [in][optional] command-buffer descriptor.
-    ur_exp_command_buffer_handle_t
-        *phCommandBuffer ///< [out] Pointer to command-Buffer handle.
-) {
+ur_result_t UR_APICALL
+urCommandBufferCreateExp(
+    ur_context_handle_t hContext,                   ///< [in] Handle of the context object.
+    ur_device_handle_t hDevice,                     ///< [in] Handle of the device object.
+    const ur_exp_command_buffer_desc_t* pCommandBufferDesc, ///< [in][optional] command-buffer descriptor.
+    ur_exp_command_buffer_handle_t* phCommandBuffer ///< [out] Pointer to command-Buffer handle.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Increment the command-buffer object's reference count.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6342,10 +6266,11 @@ ur_result_t UR_APICALL urCommandBufferCreateExp(
 ///     - ::UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_EXP
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urCommandBufferRetainExp(
-    ur_exp_command_buffer_handle_t
-        hCommandBuffer ///< [in][retain] Handle of the command-buffer object.
-) {
+ur_result_t UR_APICALL
+urCommandBufferRetainExp(
+    ur_exp_command_buffer_handle_t hCommandBuffer   ///< [in][retain] Handle of the command-buffer object.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -6353,7 +6278,7 @@ ur_result_t UR_APICALL urCommandBufferRetainExp(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Decrement the command-buffer object's reference count and delete the
 ///        command-buffer object if the reference count becomes zero.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6364,10 +6289,11 @@ ur_result_t UR_APICALL urCommandBufferRetainExp(
 ///     - ::UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_EXP
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urCommandBufferReleaseExp(
-    ur_exp_command_buffer_handle_t
-        hCommandBuffer ///< [in][release] Handle of the command-buffer object.
-) {
+ur_result_t UR_APICALL
+urCommandBufferReleaseExp(
+    ur_exp_command_buffer_handle_t hCommandBuffer   ///< [in][release] Handle of the command-buffer object.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -6375,7 +6301,7 @@ ur_result_t UR_APICALL urCommandBufferReleaseExp(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Stop recording on a command-buffer object such that no more commands
 ///        can be appended and make it ready to enqueue.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6386,17 +6312,18 @@ ur_result_t UR_APICALL urCommandBufferReleaseExp(
 ///     - ::UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_EXP
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urCommandBufferFinalizeExp(
-    ur_exp_command_buffer_handle_t
-        hCommandBuffer ///< [in] Handle of the command-buffer object.
-) {
+ur_result_t UR_APICALL
+urCommandBufferFinalizeExp(
+    ur_exp_command_buffer_handle_t hCommandBuffer   ///< [in] Handle of the command-buffer object.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Append a kernel execution command to a command-buffer object.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6429,54 +6356,44 @@ ur_result_t UR_APICALL urCommandBufferFinalizeExp(
 ///         + If the device associated with `hCommandBuffer` does not support UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP and either `phEvent` or `phEventWaitList` are not NULL.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urCommandBufferAppendKernelLaunchExp(
-    ur_exp_command_buffer_handle_t
-        hCommandBuffer,         ///< [in] Handle of the command-buffer object.
-    ur_kernel_handle_t hKernel, ///< [in] Kernel to append.
-    uint32_t workDim,           ///< [in] Dimension of the kernel execution.
-    const size_t
-        *pGlobalWorkOffset, ///< [in] Offset to use when executing kernel.
-    const size_t *
-        pGlobalWorkSize, ///< [in] Global work size to use when executing kernel.
-    const size_t *
-        pLocalWorkSize, ///< [in][optional] Local work size to use when executing kernel. If this
-    ///< parameter is nullptr, then a local work size will be generated by the
-    ///< implementation.
-    uint32_t
-        numKernelAlternatives, ///< [in] The number of kernel alternatives provided in
-                               ///< phKernelAlternatives.
-    ur_kernel_handle_t *
-        phKernelAlternatives, ///< [in][optional][range(0, numKernelAlternatives)] List of kernel handles
-    ///< that might be used to update the kernel in this
-    ///< command after the command-buffer is finalized. The default kernel
-    ///< `hKernel` is implicitly marked as an alternative. It's
-    ///< invalid to specify it as part of this list.
-    uint32_t
-        numSyncPointsInWaitList, ///< [in] The number of sync points in the provided dependency list.
-    const ur_exp_command_buffer_sync_point_t *
-        pSyncPointWaitList, ///< [in][optional] A list of sync points that this command depends on. May
-                            ///< be ignored if command-buffer is in-order.
-    uint32_t numEventsInWaitList, ///< [in] Size of the event wait list.
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the command execution. If nullptr,
-    ///< the numEventsInWaitList must be 0, indicating no wait events.
-    ur_exp_command_buffer_sync_point_t *
-        pSyncPoint, ///< [out][optional] Sync point associated with this command.
-    ur_event_handle_t *
-        phEvent, ///< [out][optional] return an event object that will be signaled by the
-                 ///< completion of this command in the next execution of the
-                 ///< command-buffer.
-    ur_exp_command_buffer_command_handle_t
-        *phCommand ///< [out][optional] Handle to this command.
-) {
+ur_result_t UR_APICALL
+urCommandBufferAppendKernelLaunchExp(
+    ur_exp_command_buffer_handle_t hCommandBuffer,  ///< [in] Handle of the command-buffer object.
+    ur_kernel_handle_t hKernel,                     ///< [in] Kernel to append.
+    uint32_t workDim,                               ///< [in] Dimension of the kernel execution.
+    const size_t* pGlobalWorkOffset,                ///< [in] Offset to use when executing kernel.
+    const size_t* pGlobalWorkSize,                  ///< [in] Global work size to use when executing kernel.
+    const size_t* pLocalWorkSize,                   ///< [in][optional] Local work size to use when executing kernel. If this
+                                                    ///< parameter is nullptr, then a local work size will be generated by the
+                                                    ///< implementation.
+    uint32_t numKernelAlternatives,                 ///< [in] The number of kernel alternatives provided in
+                                                    ///< phKernelAlternatives.
+    ur_kernel_handle_t* phKernelAlternatives,       ///< [in][optional][range(0, numKernelAlternatives)] List of kernel handles
+                                                    ///< that might be used to update the kernel in this
+                                                    ///< command after the command-buffer is finalized. The default kernel
+                                                    ///< `hKernel` is implicitly marked as an alternative. It's
+                                                    ///< invalid to specify it as part of this list.
+    uint32_t numSyncPointsInWaitList,               ///< [in] The number of sync points in the provided dependency list.
+    const ur_exp_command_buffer_sync_point_t* pSyncPointWaitList,   ///< [in][optional] A list of sync points that this command depends on. May
+                                                    ///< be ignored if command-buffer is in-order.
+    uint32_t numEventsInWaitList,                   ///< [in] Size of the event wait list.
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the command execution. If nullptr,
+                                                    ///< the numEventsInWaitList must be 0, indicating no wait events.
+    ur_exp_command_buffer_sync_point_t* pSyncPoint, ///< [out][optional] Sync point associated with this command.
+    ur_event_handle_t* phEvent,                     ///< [out][optional] return an event object that will be signaled by the
+                                                    ///< completion of this command in the next execution of the
+                                                    ///< command-buffer.
+    ur_exp_command_buffer_command_handle_t* phCommand   ///< [out][optional] Handle to this command.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Append a USM memcpy command to a command-buffer object.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6505,38 +6422,33 @@ ur_result_t UR_APICALL urCommandBufferAppendKernelLaunchExp(
 ///         + If the device associated with `hCommandBuffer` does not support UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP and either `phEvent` or `phEventWaitList` are not NULL.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urCommandBufferAppendUSMMemcpyExp(
-    ur_exp_command_buffer_handle_t
-        hCommandBuffer, ///< [in] Handle of the command-buffer object.
-    void *pDst,         ///< [in] Location the data will be copied to.
-    const void *pSrc,   ///< [in] The data to be copied.
-    size_t size,        ///< [in] The number of bytes to copy.
-    uint32_t
-        numSyncPointsInWaitList, ///< [in] The number of sync points in the provided dependency list.
-    const ur_exp_command_buffer_sync_point_t *
-        pSyncPointWaitList, ///< [in][optional] A list of sync points that this command depends on. May
-                            ///< be ignored if command-buffer is in-order.
-    uint32_t numEventsInWaitList, ///< [in] Size of the event wait list.
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the command execution. If nullptr,
-    ///< the numEventsInWaitList must be 0, indicating no wait events.
-    ur_exp_command_buffer_sync_point_t *
-        pSyncPoint, ///< [out][optional] Sync point associated with this command.
-    ur_event_handle_t *
-        phEvent, ///< [out][optional] return an event object that will be signaled by the
-                 ///< completion of this command in the next execution of the
-                 ///< command-buffer.
-    ur_exp_command_buffer_command_handle_t
-        *phCommand ///< [out][optional] Handle to this command.
-) {
+ur_result_t UR_APICALL
+urCommandBufferAppendUSMMemcpyExp(
+    ur_exp_command_buffer_handle_t hCommandBuffer,  ///< [in] Handle of the command-buffer object.
+    void* pDst,                                     ///< [in] Location the data will be copied to.
+    const void* pSrc,                               ///< [in] The data to be copied.
+    size_t size,                                    ///< [in] The number of bytes to copy.
+    uint32_t numSyncPointsInWaitList,               ///< [in] The number of sync points in the provided dependency list.
+    const ur_exp_command_buffer_sync_point_t* pSyncPointWaitList,   ///< [in][optional] A list of sync points that this command depends on. May
+                                                    ///< be ignored if command-buffer is in-order.
+    uint32_t numEventsInWaitList,                   ///< [in] Size of the event wait list.
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the command execution. If nullptr,
+                                                    ///< the numEventsInWaitList must be 0, indicating no wait events.
+    ur_exp_command_buffer_sync_point_t* pSyncPoint, ///< [out][optional] Sync point associated with this command.
+    ur_event_handle_t* phEvent,                     ///< [out][optional] return an event object that will be signaled by the
+                                                    ///< completion of this command in the next execution of the
+                                                    ///< command-buffer.
+    ur_exp_command_buffer_command_handle_t* phCommand   ///< [out][optional] Handle to this command.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Append a USM fill command to a command-buffer object.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6567,40 +6479,34 @@ ur_result_t UR_APICALL urCommandBufferAppendUSMMemcpyExp(
 ///         + If the device associated with `hCommandBuffer` does not support UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP and either `phEvent` or `phEventWaitList` are not NULL.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urCommandBufferAppendUSMFillExp(
-    ur_exp_command_buffer_handle_t
-        hCommandBuffer,   ///< [in] handle of the command-buffer object.
-    void *pMemory,        ///< [in] pointer to USM allocated memory to fill.
-    const void *pPattern, ///< [in] pointer to the fill pattern.
-    size_t patternSize,   ///< [in] size in bytes of the pattern.
-    size_t
-        size, ///< [in] fill size in bytes, must be a multiple of patternSize.
-    uint32_t
-        numSyncPointsInWaitList, ///< [in] The number of sync points in the provided dependency list.
-    const ur_exp_command_buffer_sync_point_t *
-        pSyncPointWaitList, ///< [in][optional] A list of sync points that this command depends on. May
-                            ///< be ignored if command-buffer is in-order.
-    uint32_t numEventsInWaitList, ///< [in] Size of the event wait list.
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the command execution. If nullptr,
-    ///< the numEventsInWaitList must be 0, indicating no wait events.
-    ur_exp_command_buffer_sync_point_t *
-        pSyncPoint, ///< [out][optional] sync point associated with this command.
-    ur_event_handle_t *
-        phEvent, ///< [out][optional] return an event object that will be signaled by the
-                 ///< completion of this command in the next execution of the
-                 ///< command-buffer.
-    ur_exp_command_buffer_command_handle_t
-        *phCommand ///< [out][optional] Handle to this command.
-) {
+ur_result_t UR_APICALL
+urCommandBufferAppendUSMFillExp(
+    ur_exp_command_buffer_handle_t hCommandBuffer,  ///< [in] handle of the command-buffer object.
+    void* pMemory,                                  ///< [in] pointer to USM allocated memory to fill.
+    const void* pPattern,                           ///< [in] pointer to the fill pattern.
+    size_t patternSize,                             ///< [in] size in bytes of the pattern.
+    size_t size,                                    ///< [in] fill size in bytes, must be a multiple of patternSize.
+    uint32_t numSyncPointsInWaitList,               ///< [in] The number of sync points in the provided dependency list.
+    const ur_exp_command_buffer_sync_point_t* pSyncPointWaitList,   ///< [in][optional] A list of sync points that this command depends on. May
+                                                    ///< be ignored if command-buffer is in-order.
+    uint32_t numEventsInWaitList,                   ///< [in] Size of the event wait list.
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the command execution. If nullptr,
+                                                    ///< the numEventsInWaitList must be 0, indicating no wait events.
+    ur_exp_command_buffer_sync_point_t* pSyncPoint, ///< [out][optional] sync point associated with this command.
+    ur_event_handle_t* phEvent,                     ///< [out][optional] return an event object that will be signaled by the
+                                                    ///< completion of this command in the next execution of the
+                                                    ///< command-buffer.
+    ur_exp_command_buffer_command_handle_t* phCommand   ///< [out][optional] Handle to this command.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Append a memory copy command to a command-buffer object.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6625,40 +6531,35 @@ ur_result_t UR_APICALL urCommandBufferAppendUSMFillExp(
 ///         + If the device associated with `hCommandBuffer` does not support UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP and either `phEvent` or `phEventWaitList` are not NULL.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urCommandBufferAppendMemBufferCopyExp(
-    ur_exp_command_buffer_handle_t
-        hCommandBuffer,      ///< [in] Handle of the command-buffer object.
-    ur_mem_handle_t hSrcMem, ///< [in] The data to be copied.
-    ur_mem_handle_t hDstMem, ///< [in] The location the data will be copied to.
-    size_t srcOffset,        ///< [in] Offset into the source memory.
-    size_t dstOffset,        ///< [in] Offset into the destination memory
-    size_t size,             ///< [in] The number of bytes to be copied.
-    uint32_t
-        numSyncPointsInWaitList, ///< [in] The number of sync points in the provided dependency list.
-    const ur_exp_command_buffer_sync_point_t *
-        pSyncPointWaitList, ///< [in][optional] A list of sync points that this command depends on. May
-                            ///< be ignored if command-buffer is in-order.
-    uint32_t numEventsInWaitList, ///< [in] Size of the event wait list.
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the command execution. If nullptr,
-    ///< the numEventsInWaitList must be 0, indicating no wait events.
-    ur_exp_command_buffer_sync_point_t *
-        pSyncPoint, ///< [out][optional] Sync point associated with this command.
-    ur_event_handle_t *
-        phEvent, ///< [out][optional] return an event object that will be signaled by the
-                 ///< completion of this command in the next execution of the
-                 ///< command-buffer.
-    ur_exp_command_buffer_command_handle_t
-        *phCommand ///< [out][optional] Handle to this command.
-) {
+ur_result_t UR_APICALL
+urCommandBufferAppendMemBufferCopyExp(
+    ur_exp_command_buffer_handle_t hCommandBuffer,  ///< [in] Handle of the command-buffer object.
+    ur_mem_handle_t hSrcMem,                        ///< [in] The data to be copied.
+    ur_mem_handle_t hDstMem,                        ///< [in] The location the data will be copied to.
+    size_t srcOffset,                               ///< [in] Offset into the source memory.
+    size_t dstOffset,                               ///< [in] Offset into the destination memory
+    size_t size,                                    ///< [in] The number of bytes to be copied.
+    uint32_t numSyncPointsInWaitList,               ///< [in] The number of sync points in the provided dependency list.
+    const ur_exp_command_buffer_sync_point_t* pSyncPointWaitList,   ///< [in][optional] A list of sync points that this command depends on. May
+                                                    ///< be ignored if command-buffer is in-order.
+    uint32_t numEventsInWaitList,                   ///< [in] Size of the event wait list.
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the command execution. If nullptr,
+                                                    ///< the numEventsInWaitList must be 0, indicating no wait events.
+    ur_exp_command_buffer_sync_point_t* pSyncPoint, ///< [out][optional] Sync point associated with this command.
+    ur_event_handle_t* phEvent,                     ///< [out][optional] return an event object that will be signaled by the
+                                                    ///< completion of this command in the next execution of the
+                                                    ///< command-buffer.
+    ur_exp_command_buffer_command_handle_t* phCommand   ///< [out][optional] Handle to this command.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Append a memory write command to a command-buffer object.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6684,40 +6585,34 @@ ur_result_t UR_APICALL urCommandBufferAppendMemBufferCopyExp(
 ///         + If the device associated with `hCommandBuffer` does not support UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP and either `phEvent` or `phEventWaitList` are not NULL.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urCommandBufferAppendMemBufferWriteExp(
-    ur_exp_command_buffer_handle_t
-        hCommandBuffer,      ///< [in] Handle of the command-buffer object.
-    ur_mem_handle_t hBuffer, ///< [in] Handle of the buffer object.
-    size_t offset,           ///< [in] Offset in bytes in the buffer object.
-    size_t size,             ///< [in] Size in bytes of data being written.
-    const void *
-        pSrc, ///< [in] Pointer to host memory where data is to be written from.
-    uint32_t
-        numSyncPointsInWaitList, ///< [in] The number of sync points in the provided dependency list.
-    const ur_exp_command_buffer_sync_point_t *
-        pSyncPointWaitList, ///< [in][optional] A list of sync points that this command depends on. May
-                            ///< be ignored if command-buffer is in-order.
-    uint32_t numEventsInWaitList, ///< [in] Size of the event wait list.
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the command execution. If nullptr,
-    ///< the numEventsInWaitList must be 0, indicating no wait events.
-    ur_exp_command_buffer_sync_point_t *
-        pSyncPoint, ///< [out][optional] Sync point associated with this command.
-    ur_event_handle_t *
-        phEvent, ///< [out][optional] return an event object that will be signaled by the
-                 ///< completion of this command in the next execution of the
-                 ///< command-buffer.
-    ur_exp_command_buffer_command_handle_t
-        *phCommand ///< [out][optional] Handle to this command.
-) {
+ur_result_t UR_APICALL
+urCommandBufferAppendMemBufferWriteExp(
+    ur_exp_command_buffer_handle_t hCommandBuffer,  ///< [in] Handle of the command-buffer object.
+    ur_mem_handle_t hBuffer,                        ///< [in] Handle of the buffer object.
+    size_t offset,                                  ///< [in] Offset in bytes in the buffer object.
+    size_t size,                                    ///< [in] Size in bytes of data being written.
+    const void* pSrc,                               ///< [in] Pointer to host memory where data is to be written from.
+    uint32_t numSyncPointsInWaitList,               ///< [in] The number of sync points in the provided dependency list.
+    const ur_exp_command_buffer_sync_point_t* pSyncPointWaitList,   ///< [in][optional] A list of sync points that this command depends on. May
+                                                    ///< be ignored if command-buffer is in-order.
+    uint32_t numEventsInWaitList,                   ///< [in] Size of the event wait list.
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the command execution. If nullptr,
+                                                    ///< the numEventsInWaitList must be 0, indicating no wait events.
+    ur_exp_command_buffer_sync_point_t* pSyncPoint, ///< [out][optional] Sync point associated with this command.
+    ur_event_handle_t* phEvent,                     ///< [out][optional] return an event object that will be signaled by the
+                                                    ///< completion of this command in the next execution of the
+                                                    ///< command-buffer.
+    ur_exp_command_buffer_command_handle_t* phCommand   ///< [out][optional] Handle to this command.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Append a memory read command to a command-buffer object.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6743,39 +6638,34 @@ ur_result_t UR_APICALL urCommandBufferAppendMemBufferWriteExp(
 ///         + If the device associated with `hCommandBuffer` does not support UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP and either `phEvent` or `phEventWaitList` are not NULL.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urCommandBufferAppendMemBufferReadExp(
-    ur_exp_command_buffer_handle_t
-        hCommandBuffer,      ///< [in] Handle of the command-buffer object.
-    ur_mem_handle_t hBuffer, ///< [in] Handle of the buffer object.
-    size_t offset,           ///< [in] Offset in bytes in the buffer object.
-    size_t size,             ///< [in] Size in bytes of data being written.
-    void *pDst, ///< [in] Pointer to host memory where data is to be written to.
-    uint32_t
-        numSyncPointsInWaitList, ///< [in] The number of sync points in the provided dependency list.
-    const ur_exp_command_buffer_sync_point_t *
-        pSyncPointWaitList, ///< [in][optional] A list of sync points that this command depends on. May
-                            ///< be ignored if command-buffer is in-order.
-    uint32_t numEventsInWaitList, ///< [in] Size of the event wait list.
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the command execution. If nullptr,
-    ///< the numEventsInWaitList must be 0, indicating no wait events.
-    ur_exp_command_buffer_sync_point_t *
-        pSyncPoint, ///< [out][optional] Sync point associated with this command.
-    ur_event_handle_t *
-        phEvent, ///< [out][optional] return an event object that will be signaled by the
-                 ///< completion of this command in the next execution of the
-                 ///< command-buffer.
-    ur_exp_command_buffer_command_handle_t
-        *phCommand ///< [out][optional] Handle to this command.
-) {
+ur_result_t UR_APICALL
+urCommandBufferAppendMemBufferReadExp(
+    ur_exp_command_buffer_handle_t hCommandBuffer,  ///< [in] Handle of the command-buffer object.
+    ur_mem_handle_t hBuffer,                        ///< [in] Handle of the buffer object.
+    size_t offset,                                  ///< [in] Offset in bytes in the buffer object.
+    size_t size,                                    ///< [in] Size in bytes of data being written.
+    void* pDst,                                     ///< [in] Pointer to host memory where data is to be written to.
+    uint32_t numSyncPointsInWaitList,               ///< [in] The number of sync points in the provided dependency list.
+    const ur_exp_command_buffer_sync_point_t* pSyncPointWaitList,   ///< [in][optional] A list of sync points that this command depends on. May
+                                                    ///< be ignored if command-buffer is in-order.
+    uint32_t numEventsInWaitList,                   ///< [in] Size of the event wait list.
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the command execution. If nullptr,
+                                                    ///< the numEventsInWaitList must be 0, indicating no wait events.
+    ur_exp_command_buffer_sync_point_t* pSyncPoint, ///< [out][optional] Sync point associated with this command.
+    ur_event_handle_t* phEvent,                     ///< [out][optional] return an event object that will be signaled by the
+                                                    ///< completion of this command in the next execution of the
+                                                    ///< command-buffer.
+    ur_exp_command_buffer_command_handle_t* phCommand   ///< [out][optional] Handle to this command.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Append a rectangular memory copy command to a command-buffer object.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6800,47 +6690,39 @@ ur_result_t UR_APICALL urCommandBufferAppendMemBufferReadExp(
 ///         + If the device associated with `hCommandBuffer` does not support UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP and either `phEvent` or `phEventWaitList` are not NULL.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urCommandBufferAppendMemBufferCopyRectExp(
-    ur_exp_command_buffer_handle_t
-        hCommandBuffer,      ///< [in] Handle of the command-buffer object.
-    ur_mem_handle_t hSrcMem, ///< [in] The data to be copied.
-    ur_mem_handle_t hDstMem, ///< [in] The location the data will be copied to.
-    ur_rect_offset_t
-        srcOrigin, ///< [in] Origin for the region of data to be copied from the source.
-    ur_rect_offset_t
-        dstOrigin, ///< [in] Origin for the region of data to be copied to in the destination.
-    ur_rect_region_t
-        region, ///< [in] The extents describing the region to be copied.
-    size_t srcRowPitch,   ///< [in] Row pitch of the source memory.
-    size_t srcSlicePitch, ///< [in] Slice pitch of the source memory.
-    size_t dstRowPitch,   ///< [in] Row pitch of the destination memory.
-    size_t dstSlicePitch, ///< [in] Slice pitch of the destination memory.
-    uint32_t
-        numSyncPointsInWaitList, ///< [in] The number of sync points in the provided dependency list.
-    const ur_exp_command_buffer_sync_point_t *
-        pSyncPointWaitList, ///< [in][optional] A list of sync points that this command depends on. May
-                            ///< be ignored if command-buffer is in-order.
-    uint32_t numEventsInWaitList, ///< [in] Size of the event wait list.
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the command execution. If nullptr,
-    ///< the numEventsInWaitList must be 0, indicating no wait events.
-    ur_exp_command_buffer_sync_point_t *
-        pSyncPoint, ///< [out][optional] Sync point associated with this command.
-    ur_event_handle_t *
-        phEvent, ///< [out][optional] return an event object that will be signaled by the
-                 ///< completion of this command in the next execution of the
-                 ///< command-buffer.
-    ur_exp_command_buffer_command_handle_t
-        *phCommand ///< [out][optional] Handle to this command.
-) {
+ur_result_t UR_APICALL
+urCommandBufferAppendMemBufferCopyRectExp(
+    ur_exp_command_buffer_handle_t hCommandBuffer,  ///< [in] Handle of the command-buffer object.
+    ur_mem_handle_t hSrcMem,                        ///< [in] The data to be copied.
+    ur_mem_handle_t hDstMem,                        ///< [in] The location the data will be copied to.
+    ur_rect_offset_t srcOrigin,                     ///< [in] Origin for the region of data to be copied from the source.
+    ur_rect_offset_t dstOrigin,                     ///< [in] Origin for the region of data to be copied to in the destination.
+    ur_rect_region_t region,                        ///< [in] The extents describing the region to be copied.
+    size_t srcRowPitch,                             ///< [in] Row pitch of the source memory.
+    size_t srcSlicePitch,                           ///< [in] Slice pitch of the source memory.
+    size_t dstRowPitch,                             ///< [in] Row pitch of the destination memory.
+    size_t dstSlicePitch,                           ///< [in] Slice pitch of the destination memory.
+    uint32_t numSyncPointsInWaitList,               ///< [in] The number of sync points in the provided dependency list.
+    const ur_exp_command_buffer_sync_point_t* pSyncPointWaitList,   ///< [in][optional] A list of sync points that this command depends on. May
+                                                    ///< be ignored if command-buffer is in-order.
+    uint32_t numEventsInWaitList,                   ///< [in] Size of the event wait list.
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the command execution. If nullptr,
+                                                    ///< the numEventsInWaitList must be 0, indicating no wait events.
+    ur_exp_command_buffer_sync_point_t* pSyncPoint, ///< [out][optional] Sync point associated with this command.
+    ur_event_handle_t* phEvent,                     ///< [out][optional] return an event object that will be signaled by the
+                                                    ///< completion of this command in the next execution of the
+                                                    ///< command-buffer.
+    ur_exp_command_buffer_command_handle_t* phCommand   ///< [out][optional] Handle to this command.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Append a rectangular memory write command to a command-buffer object.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6866,53 +6748,42 @@ ur_result_t UR_APICALL urCommandBufferAppendMemBufferCopyRectExp(
 ///         + If the device associated with `hCommandBuffer` does not support UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP and either `phEvent` or `phEventWaitList` are not NULL.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urCommandBufferAppendMemBufferWriteRectExp(
-    ur_exp_command_buffer_handle_t
-        hCommandBuffer,      ///< [in] Handle of the command-buffer object.
-    ur_mem_handle_t hBuffer, ///< [in] Handle of the buffer object.
-    ur_rect_offset_t bufferOffset, ///< [in] 3D offset in the buffer.
-    ur_rect_offset_t hostOffset,   ///< [in] 3D offset in the host region.
-    ur_rect_region_t
-        region, ///< [in] 3D rectangular region descriptor: width, height, depth.
-    size_t
-        bufferRowPitch, ///< [in] Length of each row in bytes in the buffer object.
-    size_t
-        bufferSlicePitch, ///< [in] Length of each 2D slice in bytes in the buffer object being
-                          ///< written.
-    size_t
-        hostRowPitch, ///< [in] Length of each row in bytes in the host memory region pointed to
-                      ///< by pSrc.
-    size_t
-        hostSlicePitch, ///< [in] Length of each 2D slice in bytes in the host memory region
-                        ///< pointed to by pSrc.
-    void *
-        pSrc, ///< [in] Pointer to host memory where data is to be written from.
-    uint32_t
-        numSyncPointsInWaitList, ///< [in] The number of sync points in the provided dependency list.
-    const ur_exp_command_buffer_sync_point_t *
-        pSyncPointWaitList, ///< [in][optional] A list of sync points that this command depends on. May
-                            ///< be ignored if command-buffer is in-order.
-    uint32_t numEventsInWaitList, ///< [in] Size of the event wait list.
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the command execution. If nullptr,
-    ///< the numEventsInWaitList must be 0, indicating no wait events.
-    ur_exp_command_buffer_sync_point_t *
-        pSyncPoint, ///< [out][optional] Sync point associated with this command.
-    ur_event_handle_t *
-        phEvent, ///< [out][optional] return an event object that will be signaled by the
-                 ///< completion of this command in the next execution of the
-                 ///< command-buffer.
-    ur_exp_command_buffer_command_handle_t
-        *phCommand ///< [out][optional] Handle to this command.
-) {
+ur_result_t UR_APICALL
+urCommandBufferAppendMemBufferWriteRectExp(
+    ur_exp_command_buffer_handle_t hCommandBuffer,  ///< [in] Handle of the command-buffer object.
+    ur_mem_handle_t hBuffer,                        ///< [in] Handle of the buffer object.
+    ur_rect_offset_t bufferOffset,                  ///< [in] 3D offset in the buffer.
+    ur_rect_offset_t hostOffset,                    ///< [in] 3D offset in the host region.
+    ur_rect_region_t region,                        ///< [in] 3D rectangular region descriptor: width, height, depth.
+    size_t bufferRowPitch,                          ///< [in] Length of each row in bytes in the buffer object.
+    size_t bufferSlicePitch,                        ///< [in] Length of each 2D slice in bytes in the buffer object being
+                                                    ///< written.
+    size_t hostRowPitch,                            ///< [in] Length of each row in bytes in the host memory region pointed to
+                                                    ///< by pSrc.
+    size_t hostSlicePitch,                          ///< [in] Length of each 2D slice in bytes in the host memory region
+                                                    ///< pointed to by pSrc.
+    void* pSrc,                                     ///< [in] Pointer to host memory where data is to be written from.
+    uint32_t numSyncPointsInWaitList,               ///< [in] The number of sync points in the provided dependency list.
+    const ur_exp_command_buffer_sync_point_t* pSyncPointWaitList,   ///< [in][optional] A list of sync points that this command depends on. May
+                                                    ///< be ignored if command-buffer is in-order.
+    uint32_t numEventsInWaitList,                   ///< [in] Size of the event wait list.
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the command execution. If nullptr,
+                                                    ///< the numEventsInWaitList must be 0, indicating no wait events.
+    ur_exp_command_buffer_sync_point_t* pSyncPoint, ///< [out][optional] Sync point associated with this command.
+    ur_event_handle_t* phEvent,                     ///< [out][optional] return an event object that will be signaled by the
+                                                    ///< completion of this command in the next execution of the
+                                                    ///< command-buffer.
+    ur_exp_command_buffer_command_handle_t* phCommand   ///< [out][optional] Handle to this command.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Append a rectangular memory read command to a command-buffer object.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -6938,51 +6809,41 @@ ur_result_t UR_APICALL urCommandBufferAppendMemBufferWriteRectExp(
 ///         + If the device associated with `hCommandBuffer` does not support UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP and either `phEvent` or `phEventWaitList` are not NULL.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urCommandBufferAppendMemBufferReadRectExp(
-    ur_exp_command_buffer_handle_t
-        hCommandBuffer,      ///< [in] Handle of the command-buffer object.
-    ur_mem_handle_t hBuffer, ///< [in] Handle of the buffer object.
-    ur_rect_offset_t bufferOffset, ///< [in] 3D offset in the buffer.
-    ur_rect_offset_t hostOffset,   ///< [in] 3D offset in the host region.
-    ur_rect_region_t
-        region, ///< [in] 3D rectangular region descriptor: width, height, depth.
-    size_t
-        bufferRowPitch, ///< [in] Length of each row in bytes in the buffer object.
-    size_t
-        bufferSlicePitch, ///< [in] Length of each 2D slice in bytes in the buffer object being read.
-    size_t
-        hostRowPitch, ///< [in] Length of each row in bytes in the host memory region pointed to
-                      ///< by pDst.
-    size_t
-        hostSlicePitch, ///< [in] Length of each 2D slice in bytes in the host memory region
-                        ///< pointed to by pDst.
-    void *pDst, ///< [in] Pointer to host memory where data is to be read into.
-    uint32_t
-        numSyncPointsInWaitList, ///< [in] The number of sync points in the provided dependency list.
-    const ur_exp_command_buffer_sync_point_t *
-        pSyncPointWaitList, ///< [in][optional] A list of sync points that this command depends on. May
-                            ///< be ignored if command-buffer is in-order.
-    uint32_t numEventsInWaitList, ///< [in] Size of the event wait list.
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the command execution. If nullptr,
-    ///< the numEventsInWaitList must be 0, indicating no wait events.
-    ur_exp_command_buffer_sync_point_t *
-        pSyncPoint, ///< [out][optional] Sync point associated with this command.
-    ur_event_handle_t *
-        phEvent, ///< [out][optional] return an event object that will be signaled by the
-                 ///< completion of this command in the next execution of the
-                 ///< command-buffer.
-    ur_exp_command_buffer_command_handle_t
-        *phCommand ///< [out][optional] Handle to this command.
-) {
+ur_result_t UR_APICALL
+urCommandBufferAppendMemBufferReadRectExp(
+    ur_exp_command_buffer_handle_t hCommandBuffer,  ///< [in] Handle of the command-buffer object.
+    ur_mem_handle_t hBuffer,                        ///< [in] Handle of the buffer object.
+    ur_rect_offset_t bufferOffset,                  ///< [in] 3D offset in the buffer.
+    ur_rect_offset_t hostOffset,                    ///< [in] 3D offset in the host region.
+    ur_rect_region_t region,                        ///< [in] 3D rectangular region descriptor: width, height, depth.
+    size_t bufferRowPitch,                          ///< [in] Length of each row in bytes in the buffer object.
+    size_t bufferSlicePitch,                        ///< [in] Length of each 2D slice in bytes in the buffer object being read.
+    size_t hostRowPitch,                            ///< [in] Length of each row in bytes in the host memory region pointed to
+                                                    ///< by pDst.
+    size_t hostSlicePitch,                          ///< [in] Length of each 2D slice in bytes in the host memory region
+                                                    ///< pointed to by pDst.
+    void* pDst,                                     ///< [in] Pointer to host memory where data is to be read into.
+    uint32_t numSyncPointsInWaitList,               ///< [in] The number of sync points in the provided dependency list.
+    const ur_exp_command_buffer_sync_point_t* pSyncPointWaitList,   ///< [in][optional] A list of sync points that this command depends on. May
+                                                    ///< be ignored if command-buffer is in-order.
+    uint32_t numEventsInWaitList,                   ///< [in] Size of the event wait list.
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the command execution. If nullptr,
+                                                    ///< the numEventsInWaitList must be 0, indicating no wait events.
+    ur_exp_command_buffer_sync_point_t* pSyncPoint, ///< [out][optional] Sync point associated with this command.
+    ur_event_handle_t* phEvent,                     ///< [out][optional] return an event object that will be signaled by the
+                                                    ///< completion of this command in the next execution of the
+                                                    ///< command-buffer.
+    ur_exp_command_buffer_command_handle_t* phCommand   ///< [out][optional] Handle to this command.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Append a memory fill command to a command-buffer object.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7010,46 +6871,40 @@ ur_result_t UR_APICALL urCommandBufferAppendMemBufferReadRectExp(
 ///         + If the device associated with `hCommandBuffer` does not support UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP and either `phEvent` or `phEventWaitList` are not NULL.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urCommandBufferAppendMemBufferFillExp(
-    ur_exp_command_buffer_handle_t
-        hCommandBuffer,      ///< [in] handle of the command-buffer object.
-    ur_mem_handle_t hBuffer, ///< [in] handle of the buffer object.
-    const void *pPattern,    ///< [in] pointer to the fill pattern.
-    size_t patternSize,      ///< [in] size in bytes of the pattern.
-    size_t offset,           ///< [in] offset into the buffer.
-    size_t
-        size, ///< [in] fill size in bytes, must be a multiple of patternSize.
-    uint32_t
-        numSyncPointsInWaitList, ///< [in] The number of sync points in the provided dependency list.
-    const ur_exp_command_buffer_sync_point_t *
-        pSyncPointWaitList, ///< [in][optional] A list of sync points that this command depends on. May
-                            ///< be ignored if command-buffer is in-order.
-    uint32_t numEventsInWaitList, ///< [in] Size of the event wait list.
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the command execution. If nullptr,
-    ///< the numEventsInWaitList must be 0, indicating no wait events.
-    ur_exp_command_buffer_sync_point_t *
-        pSyncPoint, ///< [out][optional] sync point associated with this command.
-    ur_event_handle_t *
-        phEvent, ///< [out][optional] return an event object that will be signaled by the
-                 ///< completion of this command in the next execution of the
-                 ///< command-buffer.
-    ur_exp_command_buffer_command_handle_t
-        *phCommand ///< [out][optional] Handle to this command.
-) {
+ur_result_t UR_APICALL
+urCommandBufferAppendMemBufferFillExp(
+    ur_exp_command_buffer_handle_t hCommandBuffer,  ///< [in] handle of the command-buffer object.
+    ur_mem_handle_t hBuffer,                        ///< [in] handle of the buffer object.
+    const void* pPattern,                           ///< [in] pointer to the fill pattern.
+    size_t patternSize,                             ///< [in] size in bytes of the pattern.
+    size_t offset,                                  ///< [in] offset into the buffer.
+    size_t size,                                    ///< [in] fill size in bytes, must be a multiple of patternSize.
+    uint32_t numSyncPointsInWaitList,               ///< [in] The number of sync points in the provided dependency list.
+    const ur_exp_command_buffer_sync_point_t* pSyncPointWaitList,   ///< [in][optional] A list of sync points that this command depends on. May
+                                                    ///< be ignored if command-buffer is in-order.
+    uint32_t numEventsInWaitList,                   ///< [in] Size of the event wait list.
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the command execution. If nullptr,
+                                                    ///< the numEventsInWaitList must be 0, indicating no wait events.
+    ur_exp_command_buffer_sync_point_t* pSyncPoint, ///< [out][optional] sync point associated with this command.
+    ur_event_handle_t* phEvent,                     ///< [out][optional] return an event object that will be signaled by the
+                                                    ///< completion of this command in the next execution of the
+                                                    ///< command-buffer.
+    ur_exp_command_buffer_command_handle_t* phCommand   ///< [out][optional] Handle to this command.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Append a USM Prefetch command to a command-buffer object.
-///
+/// 
 /// @details
 ///     - Prefetching may not be supported for all devices or allocation types.
 ///       If memory prefetching is not supported, the prefetch hint will be
 ///       ignored.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7079,43 +6934,38 @@ ur_result_t UR_APICALL urCommandBufferAppendMemBufferFillExp(
 ///         + If the device associated with `hCommandBuffer` does not support UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP and either `phEvent` or `phEventWaitList` are not NULL.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urCommandBufferAppendUSMPrefetchExp(
-    ur_exp_command_buffer_handle_t
-        hCommandBuffer,  ///< [in] handle of the command-buffer object.
-    const void *pMemory, ///< [in] pointer to USM allocated memory to prefetch.
-    size_t size,         ///< [in] size in bytes to be fetched.
-    ur_usm_migration_flags_t flags, ///< [in] USM prefetch flags
-    uint32_t
-        numSyncPointsInWaitList, ///< [in] The number of sync points in the provided dependency list.
-    const ur_exp_command_buffer_sync_point_t *
-        pSyncPointWaitList, ///< [in][optional] A list of sync points that this command depends on. May
-                            ///< be ignored if command-buffer is in-order.
-    uint32_t numEventsInWaitList, ///< [in] Size of the event wait list.
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the command execution. If nullptr,
-    ///< the numEventsInWaitList must be 0, indicating no wait events.
-    ur_exp_command_buffer_sync_point_t *
-        pSyncPoint, ///< [out][optional] sync point associated with this command.
-    ur_event_handle_t *
-        phEvent, ///< [out][optional] return an event object that will be signaled by the
-                 ///< completion of this command in the next execution of the
-                 ///< command-buffer.
-    ur_exp_command_buffer_command_handle_t
-        *phCommand ///< [out][optional] Handle to this command.
-) {
+ur_result_t UR_APICALL
+urCommandBufferAppendUSMPrefetchExp(
+    ur_exp_command_buffer_handle_t hCommandBuffer,  ///< [in] handle of the command-buffer object.
+    const void* pMemory,                            ///< [in] pointer to USM allocated memory to prefetch.
+    size_t size,                                    ///< [in] size in bytes to be fetched.
+    ur_usm_migration_flags_t flags,                 ///< [in] USM migration flags
+    uint32_t numSyncPointsInWaitList,               ///< [in] The number of sync points in the provided dependency list.
+    const ur_exp_command_buffer_sync_point_t* pSyncPointWaitList,   ///< [in][optional] A list of sync points that this command depends on. May
+                                                    ///< be ignored if command-buffer is in-order.
+    uint32_t numEventsInWaitList,                   ///< [in] Size of the event wait list.
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the command execution. If nullptr,
+                                                    ///< the numEventsInWaitList must be 0, indicating no wait events.
+    ur_exp_command_buffer_sync_point_t* pSyncPoint, ///< [out][optional] sync point associated with this command.
+    ur_event_handle_t* phEvent,                     ///< [out][optional] return an event object that will be signaled by the
+                                                    ///< completion of this command in the next execution of the
+                                                    ///< command-buffer.
+    ur_exp_command_buffer_command_handle_t* phCommand   ///< [out][optional] Handle to this command.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Append a USM Advise command to a command-buffer object.
-///
+/// 
 /// @details
 ///     - Not all memory advice hints may be supported for all devices or
 ///       allocation types. If a memory advice hint is not supported, it will be
 ///       ignored.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7145,38 +6995,33 @@ ur_result_t UR_APICALL urCommandBufferAppendUSMPrefetchExp(
 ///         + If the device associated with `hCommandBuffer` does not support UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP and either `phEvent` or `phEventWaitList` are not NULL.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urCommandBufferAppendUSMAdviseExp(
-    ur_exp_command_buffer_handle_t
-        hCommandBuffer,           ///< [in] handle of the command-buffer object.
-    const void *pMemory,          ///< [in] pointer to the USM memory object.
-    size_t size,                  ///< [in] size in bytes to be advised.
-    ur_usm_advice_flags_t advice, ///< [in] USM memory advice
-    uint32_t
-        numSyncPointsInWaitList, ///< [in] The number of sync points in the provided dependency list.
-    const ur_exp_command_buffer_sync_point_t *
-        pSyncPointWaitList, ///< [in][optional] A list of sync points that this command depends on. May
-                            ///< be ignored if command-buffer is in-order.
-    uint32_t numEventsInWaitList, ///< [in] Size of the event wait list.
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the command execution. If nullptr,
-    ///< the numEventsInWaitList must be 0, indicating no wait events.
-    ur_exp_command_buffer_sync_point_t *
-        pSyncPoint, ///< [out][optional] sync point associated with this command.
-    ur_event_handle_t *
-        phEvent, ///< [out][optional] return an event object that will be signaled by the
-                 ///< completion of this command in the next execution of the
-                 ///< command-buffer.
-    ur_exp_command_buffer_command_handle_t
-        *phCommand ///< [out][optional] Handle to this command.
-) {
+ur_result_t UR_APICALL
+urCommandBufferAppendUSMAdviseExp(
+    ur_exp_command_buffer_handle_t hCommandBuffer,  ///< [in] handle of the command-buffer object.
+    const void* pMemory,                            ///< [in] pointer to the USM memory object.
+    size_t size,                                    ///< [in] size in bytes to be advised.
+    ur_usm_advice_flags_t advice,                   ///< [in] USM memory advice
+    uint32_t numSyncPointsInWaitList,               ///< [in] The number of sync points in the provided dependency list.
+    const ur_exp_command_buffer_sync_point_t* pSyncPointWaitList,   ///< [in][optional] A list of sync points that this command depends on. May
+                                                    ///< be ignored if command-buffer is in-order.
+    uint32_t numEventsInWaitList,                   ///< [in] Size of the event wait list.
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the command execution. If nullptr,
+                                                    ///< the numEventsInWaitList must be 0, indicating no wait events.
+    ur_exp_command_buffer_sync_point_t* pSyncPoint, ///< [out][optional] sync point associated with this command.
+    ur_event_handle_t* phEvent,                     ///< [out][optional] return an event object that will be signaled by the
+                                                    ///< completion of this command in the next execution of the
+                                                    ///< command-buffer.
+    ur_exp_command_buffer_command_handle_t* phCommand   ///< [out][optional] Handle to this command.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Submit a command-buffer for execution on a queue.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7194,28 +7039,26 @@ ur_result_t UR_APICALL urCommandBufferAppendUSMAdviseExp(
 ///         + If event objects in phEventWaitList are not valid events.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urCommandBufferEnqueueExp(
-    ur_exp_command_buffer_handle_t
-        hCommandBuffer, ///< [in] Handle of the command-buffer object.
-    ur_queue_handle_t
-        hQueue, ///< [in] The queue to submit this command-buffer for execution.
-    uint32_t numEventsInWaitList, ///< [in] Size of the event wait list.
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the command-buffer execution.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating no wait events.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command-buffer execution instance. If phEventWaitList and phEvent are
-    ///< not NULL, phEvent must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urCommandBufferEnqueueExp(
+    ur_exp_command_buffer_handle_t hCommandBuffer,  ///< [in] Handle of the command-buffer object.
+    ur_queue_handle_t hQueue,                       ///< [in] The queue to submit this command-buffer for execution.
+    uint32_t numEventsInWaitList,                   ///< [in] Size of the event wait list.
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the command-buffer execution.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating no wait events.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command-buffer execution instance. If phEventWaitList and phEvent are
+                                                    ///< not NULL, phEvent must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Increment the command object's reference count.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7226,10 +7069,11 @@ ur_result_t UR_APICALL urCommandBufferEnqueueExp(
 ///     - ::UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_COMMAND_HANDLE_EXP
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urCommandBufferRetainCommandExp(
-    ur_exp_command_buffer_command_handle_t
-        hCommand ///< [in][retain] Handle of the command-buffer command.
-) {
+ur_result_t UR_APICALL
+urCommandBufferRetainCommandExp(
+    ur_exp_command_buffer_command_handle_t hCommand ///< [in][retain] Handle of the command-buffer command.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -7237,7 +7081,7 @@ ur_result_t UR_APICALL urCommandBufferRetainCommandExp(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Decrement the command object's reference count and delete the command
 ///        object if the reference count becomes zero.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7248,20 +7092,21 @@ ur_result_t UR_APICALL urCommandBufferRetainCommandExp(
 ///     - ::UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_COMMAND_HANDLE_EXP
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urCommandBufferReleaseCommandExp(
-    ur_exp_command_buffer_command_handle_t
-        hCommand ///< [in][release] Handle of the command-buffer command.
-) {
+ur_result_t UR_APICALL
+urCommandBufferReleaseCommandExp(
+    ur_exp_command_buffer_command_handle_t hCommand ///< [in][release] Handle of the command-buffer command.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Update a kernel launch command in a finalized command-buffer.
-///
+/// 
 /// @details
 /// This entry-point is synchronous and may block if the command-buffer is executing when the entry-point is called.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7289,12 +7134,12 @@ ur_result_t UR_APICALL urCommandBufferReleaseCommandExp(
 ///         + If `pUpdateKernelLaunch->newWorkDim` is different from the current workDim in `hCommand` and, pUpdateKernelLaunch->pNewGlobalWorkSize, or pUpdateKernelLaunch->pNewGlobalWorkOffset are nullptr.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urCommandBufferUpdateKernelLaunchExp(
-    ur_exp_command_buffer_command_handle_t
-        hCommand, ///< [in] Handle of the command-buffer kernel command to update.
-    const ur_exp_command_buffer_update_kernel_launch_desc_t *
-        pUpdateKernelLaunch ///< [in] Struct defining how the kernel command is to be updated.
-) {
+ur_result_t UR_APICALL
+urCommandBufferUpdateKernelLaunchExp(
+    ur_exp_command_buffer_command_handle_t hCommand,///< [in] Handle of the command-buffer kernel command to update.
+    const ur_exp_command_buffer_update_kernel_launch_desc_t* pUpdateKernelLaunch///< [in] Struct defining how the kernel command is to be updated.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -7302,10 +7147,10 @@ ur_result_t UR_APICALL urCommandBufferUpdateKernelLaunchExp(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Get a new event that will be signaled the next time the command in the
 ///        command-buffer executes.
-///
+/// 
 /// @details
 /// It is the users responsibility to release the returned `phSignalEvent`.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7325,11 +7170,12 @@ ur_result_t UR_APICALL urCommandBufferUpdateKernelLaunchExp(
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urCommandBufferUpdateSignalEventExp(
-    ur_exp_command_buffer_command_handle_t
-        hCommand, ///< [in] Handle of the command-buffer command to update.
-    ur_event_handle_t *phSignalEvent ///< [out] Event to be signaled.
-) {
+ur_result_t UR_APICALL
+urCommandBufferUpdateSignalEventExp(
+    ur_exp_command_buffer_command_handle_t hCommand,///< [in] Handle of the command-buffer command to update.
+    ur_event_handle_t* phSignalEvent                ///< [out] Event to be signaled.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -7337,7 +7183,7 @@ ur_result_t UR_APICALL urCommandBufferUpdateSignalEventExp(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Set the list of wait events for a command to depend on to a list of
 ///        new events.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7358,22 +7204,22 @@ ur_result_t UR_APICALL urCommandBufferUpdateSignalEventExp(
 ///         + If `numEventsInWaitList` does not match the number of wait events set when the command associated with `hCommand` was created.
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urCommandBufferUpdateWaitEventsExp(
-    ur_exp_command_buffer_command_handle_t
-        hCommand, ///< [in] Handle of the command-buffer command to update.
-    uint32_t numEventsInWaitList, ///< [in] Size of the event wait list.
-    const ur_event_handle_t *
-        phEventWaitList ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the command execution. If nullptr,
-    ///< the numEventsInWaitList must be 0, indicating no wait events.
-) {
+ur_result_t UR_APICALL
+urCommandBufferUpdateWaitEventsExp(
+    ur_exp_command_buffer_command_handle_t hCommand,///< [in] Handle of the command-buffer command to update.
+    uint32_t numEventsInWaitList,                   ///< [in] Size of the event wait list.
+    const ur_event_handle_t* phEventWaitList        ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the command execution. If nullptr,
+                                                    ///< the numEventsInWaitList must be 0, indicating no wait events.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Get command-buffer object information.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7394,26 +7240,23 @@ ur_result_t UR_APICALL urCommandBufferUpdateWaitEventsExp(
 ///     - ::UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_EXP
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urCommandBufferGetInfoExp(
-    ur_exp_command_buffer_handle_t
-        hCommandBuffer, ///< [in] handle of the command-buffer object
-    ur_exp_command_buffer_info_t
-        propName, ///< [in] the name of the command-buffer property to query
-    size_t
-        propSize, ///< [in] size in bytes of the command-buffer property value
-    void *
-        pPropValue, ///< [out][optional][typename(propName, propSize)] value of the
-                    ///< command-buffer property
-    size_t *
-        pPropSizeRet ///< [out][optional] bytes returned in command-buffer property
-) {
+ur_result_t UR_APICALL
+urCommandBufferGetInfoExp(
+    ur_exp_command_buffer_handle_t hCommandBuffer,  ///< [in] handle of the command-buffer object
+    ur_exp_command_buffer_info_t propName,          ///< [in] the name of the command-buffer property to query
+    size_t propSize,                                ///< [in] size in bytes of the command-buffer property value
+    void* pPropValue,                               ///< [out][optional][typename(propName, propSize)] value of the
+                                                    ///< command-buffer property
+    size_t* pPropSizeRet                            ///< [out][optional] bytes returned in command-buffer property
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Get command-buffer object information.
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7434,26 +7277,23 @@ ur_result_t UR_APICALL urCommandBufferGetInfoExp(
 ///     - ::UR_RESULT_ERROR_INVALID_COMMAND_BUFFER_COMMAND_HANDLE_EXP
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
-ur_result_t UR_APICALL urCommandBufferCommandGetInfoExp(
-    ur_exp_command_buffer_command_handle_t
-        hCommand, ///< [in] handle of the command-buffer command object
-    ur_exp_command_buffer_command_info_t
-        propName, ///< [in] the name of the command-buffer command property to query
-    size_t
-        propSize, ///< [in] size in bytes of the command-buffer command property value
-    void *
-        pPropValue, ///< [out][optional][typename(propName, propSize)] value of the
-                    ///< command-buffer command property
-    size_t *
-        pPropSizeRet ///< [out][optional] bytes returned in command-buffer command property
-) {
+ur_result_t UR_APICALL
+urCommandBufferCommandGetInfoExp(
+    ur_exp_command_buffer_command_handle_t hCommand,///< [in] handle of the command-buffer command object
+    ur_exp_command_buffer_command_info_t propName,  ///< [in] the name of the command-buffer command property to query
+    size_t propSize,                                ///< [in] size in bytes of the command-buffer command property value
+    void* pPropValue,                               ///< [out][optional][typename(propName, propSize)] value of the
+                                                    ///< command-buffer command property
+    size_t* pPropSizeRet                            ///< [out][optional] bytes returned in command-buffer command property
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command to execute a cooperative kernel
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7477,41 +7317,37 @@ ur_result_t UR_APICALL urCommandBufferCommandGetInfoExp(
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueCooperativeKernelLaunchExp(
-    ur_queue_handle_t hQueue,   ///< [in] handle of the queue object
-    ur_kernel_handle_t hKernel, ///< [in] handle of the kernel object
-    uint32_t
-        workDim, ///< [in] number of dimensions, from 1 to 3, to specify the global and
-                 ///< work-group work-items
-    const size_t *
-        pGlobalWorkOffset, ///< [in] pointer to an array of workDim unsigned values that specify the
-    ///< offset used to calculate the global ID of a work-item
-    const size_t *
-        pGlobalWorkSize, ///< [in] pointer to an array of workDim unsigned values that specify the
-    ///< number of global work-items in workDim that will execute the kernel
-    ///< function
-    const size_t *
-        pLocalWorkSize, ///< [in][optional] pointer to an array of workDim unsigned values that
-    ///< specify the number of local work-items forming a work-group that will
-    ///< execute the kernel function.
-    ///< If nullptr, the runtime implementation will choose the work-group size.
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the kernel execution.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that no wait event.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< kernel execution instance. If phEventWaitList and phEvent are not
-    ///< NULL, phEvent must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueCooperativeKernelLaunchExp(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    ur_kernel_handle_t hKernel,                     ///< [in] handle of the kernel object
+    uint32_t workDim,                               ///< [in] number of dimensions, from 1 to 3, to specify the global and
+                                                    ///< work-group work-items
+    const size_t* pGlobalWorkOffset,                ///< [in] pointer to an array of workDim unsigned values that specify the
+                                                    ///< offset used to calculate the global ID of a work-item
+    const size_t* pGlobalWorkSize,                  ///< [in] pointer to an array of workDim unsigned values that specify the
+                                                    ///< number of global work-items in workDim that will execute the kernel
+                                                    ///< function
+    const size_t* pLocalWorkSize,                   ///< [in][optional] pointer to an array of workDim unsigned values that
+                                                    ///< specify the number of local work-items forming a work-group that will
+                                                    ///< execute the kernel function.
+                                                    ///< If nullptr, the runtime implementation will choose the work-group size.
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the kernel execution.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that no wait event.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< kernel execution instance. If phEventWaitList and phEvent are not
+                                                    ///< NULL, phEvent must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Query the maximum number of work groups for a cooperative kernel
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7522,23 +7358,23 @@ ur_result_t UR_APICALL urEnqueueCooperativeKernelLaunchExp(
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_POINTER
 ///         + `NULL == pGroupCountRet`
 ///     - ::UR_RESULT_ERROR_INVALID_KERNEL
-ur_result_t UR_APICALL urKernelSuggestMaxCooperativeGroupCountExp(
-    ur_kernel_handle_t hKernel, ///< [in] handle of the kernel object
-    size_t
-        localWorkSize, ///< [in] number of local work-items that will form a work-group when the
-                       ///< kernel is launched
-    size_t
-        dynamicSharedMemorySize, ///< [in] size of dynamic shared memory, for each work-group, in bytes,
-    ///< that will be used when the kernel is launched
-    uint32_t *pGroupCountRet ///< [out] pointer to maximum number of groups
-) {
+ur_result_t UR_APICALL
+urKernelSuggestMaxCooperativeGroupCountExp(
+    ur_kernel_handle_t hKernel,                     ///< [in] handle of the kernel object
+    size_t localWorkSize,                           ///< [in] number of local work-items that will form a work-group when the
+                                                    ///< kernel is launched
+    size_t dynamicSharedMemorySize,                 ///< [in] size of dynamic shared memory, for each work-group, in bytes,
+                                                    ///< that will be used when the kernel is launched
+    uint32_t* pGroupCountRet                        ///< [out] pointer to maximum number of groups
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a command for recording the device timestamp
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7551,46 +7387,45 @@ ur_result_t UR_APICALL urKernelSuggestMaxCooperativeGroupCountExp(
 ///     - ::UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST
 ///         + `phEventWaitList == NULL && numEventsInWaitList > 0`
 ///         + `phEventWaitList != NULL && numEventsInWaitList == 0`
-ur_result_t UR_APICALL urEnqueueTimestampRecordingExp(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    bool
-        blocking, ///< [in] indicates whether the call to this function should block until
-    ///< until the device timestamp recording command has executed on the
-    ///< device.
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the kernel execution.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating no wait events.
-    ur_event_handle_t *
-        phEvent ///< [in,out] return an event object that identifies this particular kernel
-                ///< execution instance. Profiling information can be queried
-    ///< from this event as if `hQueue` had profiling enabled. Querying
-    ///< `UR_PROFILING_INFO_COMMAND_QUEUED` or `UR_PROFILING_INFO_COMMAND_SUBMIT`
-    ///< reports the timestamp at the time of the call to this function.
-    ///< Querying `UR_PROFILING_INFO_COMMAND_START` or `UR_PROFILING_INFO_COMMAND_END`
-    ///< reports the timestamp recorded when the command is executed on the
-    ///< device. If phEventWaitList and phEvent are not NULL, phEvent must not
-    ///< refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueTimestampRecordingExp(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    bool blocking,                                  ///< [in] indicates whether the call to this function should block until
+                                                    ///< until the device timestamp recording command has executed on the
+                                                    ///< device.
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the kernel execution.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating no wait events.
+    ur_event_handle_t* phEvent                      ///< [in,out] return an event object that identifies this particular kernel
+                                                    ///< execution instance. Profiling information can be queried
+                                                    ///< from this event as if `hQueue` had profiling enabled. Querying
+                                                    ///< `UR_PROFILING_INFO_COMMAND_QUEUED` or `UR_PROFILING_INFO_COMMAND_SUBMIT`
+                                                    ///< reports the timestamp at the time of the call to this function.
+                                                    ///< Querying `UR_PROFILING_INFO_COMMAND_START` or `UR_PROFILING_INFO_COMMAND_END`
+                                                    ///< reports the timestamp recorded when the command is executed on the
+                                                    ///< device. If phEventWaitList and phEvent are not NULL, phEvent must not
+                                                    ///< refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Launch kernel with custom launch properties
-///
+/// 
 /// @details
 ///     - Launches the kernel using the specified launch properties
 ///     - If numPropsInLaunchPropList == 0 then a regular kernel launch is used:
 ///       `urEnqueueKernelLaunch`
 ///     - Consult the appropriate adapter driver documentation for details of
 ///       adapter specific behavior and native error codes that may be returned.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **cuLaunchKernelEx**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7624,36 +7459,32 @@ ur_result_t UR_APICALL urEnqueueTimestampRecordingExp(
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueKernelLaunchCustomExp(
-    ur_queue_handle_t hQueue,   ///< [in] handle of the queue object
-    ur_kernel_handle_t hKernel, ///< [in] handle of the kernel object
-    uint32_t
-        workDim, ///< [in] number of dimensions, from 1 to 3, to specify the global and
-                 ///< work-group work-items
-    const size_t *
-        pGlobalWorkSize, ///< [in] pointer to an array of workDim unsigned values that specify the
-    ///< number of global work-items in workDim that will execute the kernel
-    ///< function
-    const size_t *
-        pLocalWorkSize, ///< [in][optional] pointer to an array of workDim unsigned values that
-    ///< specify the number of local work-items forming a work-group that will
-    ///< execute the kernel function. If nullptr, the runtime implementation
-    ///< will choose the work-group size.
-    uint32_t numPropsInLaunchPropList, ///< [in] size of the launch prop list
-    const ur_exp_launch_property_t *
-        launchPropList, ///< [in][range(0, numPropsInLaunchPropList)] pointer to a list of launch
-                        ///< properties
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the kernel execution. If nullptr,
-    ///< the numEventsInWaitList must be 0, indicating that no wait event.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< kernel execution instance. If phEventWaitList and phEvent are not
-    ///< NULL, phEvent must not refer to an element of the phEventWaitList
-    ///< array.
-) {
+ur_result_t UR_APICALL
+urEnqueueKernelLaunchCustomExp(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    ur_kernel_handle_t hKernel,                     ///< [in] handle of the kernel object
+    uint32_t workDim,                               ///< [in] number of dimensions, from 1 to 3, to specify the global and
+                                                    ///< work-group work-items
+    const size_t* pGlobalWorkSize,                  ///< [in] pointer to an array of workDim unsigned values that specify the
+                                                    ///< number of global work-items in workDim that will execute the kernel
+                                                    ///< function
+    const size_t* pLocalWorkSize,                   ///< [in][optional] pointer to an array of workDim unsigned values that
+                                                    ///< specify the number of local work-items forming a work-group that will
+                                                    ///< execute the kernel function. If nullptr, the runtime implementation
+                                                    ///< will choose the work-group size.
+    uint32_t numPropsInLaunchPropList,              ///< [in] size of the launch prop list
+    const ur_exp_launch_property_t* launchPropList, ///< [in][range(0, numPropsInLaunchPropList)] pointer to a list of launch
+                                                    ///< properties
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the kernel execution. If nullptr,
+                                                    ///< the numEventsInWaitList must be 0, indicating that no wait event. 
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< kernel execution instance. If phEventWaitList and phEvent are not
+                                                    ///< NULL, phEvent must not refer to an element of the phEventWaitList
+                                                    ///< array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
@@ -7661,17 +7492,17 @@ ur_result_t UR_APICALL urEnqueueKernelLaunchCustomExp(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Produces an executable program from one program, negates need for the
 ///        linking step.
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads.
 ///     - Following a successful call to this entry point, the program passed
 ///       will contain a binary of the ::UR_PROGRAM_BINARY_TYPE_EXECUTABLE type
 ///       for each device in `phDevices`.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clBuildProgram**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7685,31 +7516,31 @@ ur_result_t UR_APICALL urEnqueueKernelLaunchCustomExp(
 ///         + If `hProgram` isn't a valid program object.
 ///     - ::UR_RESULT_ERROR_PROGRAM_BUILD_FAILURE
 ///         + If an error occurred when building `hProgram`.
-ur_result_t UR_APICALL urProgramBuildExp(
-    ur_program_handle_t hProgram, ///< [in] Handle of the program to build.
-    uint32_t numDevices,          ///< [in] number of devices
-    ur_device_handle_t *
-        phDevices, ///< [in][range(0, numDevices)] pointer to array of device handles
-    const char *
-        pOptions ///< [in][optional] pointer to build options null-terminated string.
-) {
+ur_result_t UR_APICALL
+urProgramBuildExp(
+    ur_program_handle_t hProgram,                   ///< [in] Handle of the program to build.
+    uint32_t numDevices,                            ///< [in] number of devices
+    ur_device_handle_t* phDevices,                  ///< [in][range(0, numDevices)] pointer to array of device handles
+    const char* pOptions                            ///< [in][optional] pointer to build options null-terminated string.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Produces an executable program from one or more programs.
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads.
 ///     - Following a successful call to this entry point `hProgram` will
 ///       contain a binary of the ::UR_PROGRAM_BINARY_TYPE_COMPILED_OBJECT type
 ///       for each device in `phDevices`.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clCompileProgram**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7723,22 +7554,21 @@ ur_result_t UR_APICALL urProgramBuildExp(
 ///         + If `hProgram` isn't a valid program object.
 ///     - ::UR_RESULT_ERROR_PROGRAM_BUILD_FAILURE
 ///         + If an error occurred while compiling `hProgram`.
-ur_result_t UR_APICALL urProgramCompileExp(
-    ur_program_handle_t
-        hProgram,        ///< [in][out] handle of the program to compile.
-    uint32_t numDevices, ///< [in] number of devices
-    ur_device_handle_t *
-        phDevices, ///< [in][range(0, numDevices)] pointer to array of device handles
-    const char *
-        pOptions ///< [in][optional] pointer to build options null-terminated string.
-) {
+ur_result_t UR_APICALL
+urProgramCompileExp(
+    ur_program_handle_t hProgram,                   ///< [in][out] handle of the program to compile.
+    uint32_t numDevices,                            ///< [in] number of devices
+    ur_device_handle_t* phDevices,                  ///< [in][range(0, numDevices)] pointer to array of device handles
+    const char* pOptions                            ///< [in][optional] pointer to build options null-terminated string.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Produces an executable program from one or more programs.
-///
+/// 
 /// @details
 ///     - The application may call this function from simultaneous threads.
 ///     - Following a successful call to this entry point the program returned
@@ -7750,11 +7580,11 @@ ur_result_t UR_APICALL urProgramCompileExp(
 ///       use the build log of this program (accessible via
 ///       ::urProgramGetBuildInfo) to provide an error log for the linking
 ///       failure.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clLinkProgram**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7772,29 +7602,27 @@ ur_result_t UR_APICALL urProgramCompileExp(
 ///         + `count == 0`
 ///     - ::UR_RESULT_ERROR_PROGRAM_LINK_FAILURE
 ///         + If an error occurred while linking `phPrograms`.
-ur_result_t UR_APICALL urProgramLinkExp(
-    ur_context_handle_t hContext, ///< [in] handle of the context instance.
-    uint32_t numDevices,          ///< [in] number of devices
-    ur_device_handle_t *
-        phDevices, ///< [in][range(0, numDevices)] pointer to array of device handles
-    uint32_t count, ///< [in] number of program handles in `phPrograms`.
-    const ur_program_handle_t *
-        phPrograms, ///< [in][range(0, count)] pointer to array of program handles.
-    const char *
-        pOptions, ///< [in][optional] pointer to linker options null-terminated string.
-    ur_program_handle_t
-        *phProgram ///< [out] pointer to handle of program object created.
-) {
+ur_result_t UR_APICALL
+urProgramLinkExp(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context instance.
+    uint32_t numDevices,                            ///< [in] number of devices
+    ur_device_handle_t* phDevices,                  ///< [in][range(0, numDevices)] pointer to array of device handles
+    uint32_t count,                                 ///< [in] number of program handles in `phPrograms`.
+    const ur_program_handle_t* phPrograms,          ///< [in][range(0, count)] pointer to array of program handles.
+    const char* pOptions,                           ///< [in][optional] pointer to linker options null-terminated string.
+    ur_program_handle_t* phProgram                  ///< [out] pointer to handle of program object created.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Import memory into USM
-///
+/// 
 /// @details
 ///     - Import memory into USM
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7806,21 +7634,23 @@ ur_result_t UR_APICALL urProgramLinkExp(
 ///         + `NULL == pMem`
 ///     - ::UR_RESULT_ERROR_INVALID_CONTEXT
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
-ur_result_t UR_APICALL urUSMImportExp(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    void *pMem,                   ///< [in] pointer to host memory object
-    size_t size ///< [in] size in bytes of the host memory object to be imported
-) {
+ur_result_t UR_APICALL
+urUSMImportExp(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    void* pMem,                                     ///< [in] pointer to host memory object
+    size_t size                                     ///< [in] size in bytes of the host memory object to be imported
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Release memory from USM
-///
+/// 
 /// @details
 ///     - Release memory from USM
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7831,17 +7661,19 @@ ur_result_t UR_APICALL urUSMImportExp(
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_POINTER
 ///         + `NULL == pMem`
 ///     - ::UR_RESULT_ERROR_INVALID_CONTEXT
-ur_result_t UR_APICALL urUSMReleaseExp(
-    ur_context_handle_t hContext, ///< [in] handle of the context object
-    void *pMem                    ///< [in] pointer to host memory object
-) {
+ur_result_t UR_APICALL
+urUSMReleaseExp(
+    ur_context_handle_t hContext,                   ///< [in] handle of the context object
+    void* pMem                                      ///< [in] pointer to host memory object
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enable access to peer device memory
-///
+/// 
 /// @details
 ///     - Enables the command device to access and write device memory
 ///       allocations located on the peer device, provided that a P2P link
@@ -7859,11 +7691,11 @@ ur_result_t UR_APICALL urUSMReleaseExp(
 ///       device.
 ///     - Consult the appropriate adapter driver documentation for details of
 ///       adapter specific behavior and native error codes that may be returned.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **cuCtxEnablePeerAccess**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7874,18 +7706,19 @@ ur_result_t UR_APICALL urUSMReleaseExp(
 ///         + `NULL == peerDevice`
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
-ur_result_t UR_APICALL urUsmP2PEnablePeerAccessExp(
-    ur_device_handle_t
-        commandDevice,            ///< [in] handle of the command device object
-    ur_device_handle_t peerDevice ///< [in] handle of the peer device object
-) {
+ur_result_t UR_APICALL
+urUsmP2PEnablePeerAccessExp(
+    ur_device_handle_t commandDevice,               ///< [in] handle of the command device object
+    ur_device_handle_t peerDevice                   ///< [in] handle of the peer device object
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Disable access to peer device memory
-///
+/// 
 /// @details
 ///     - Disables the ability of the command device to access and write device
 ///       memory allocations located on the peer device, provided that a P2P
@@ -7904,11 +7737,11 @@ ur_result_t UR_APICALL urUsmP2PEnablePeerAccessExp(
 ///       device.
 ///     - Consult the appropriate adapter driver documentation for details of
 ///       adapter specific behavior and native error codes that may be returned.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **cuCtxDisablePeerAccess**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7919,26 +7752,27 @@ ur_result_t UR_APICALL urUsmP2PEnablePeerAccessExp(
 ///         + `NULL == peerDevice`
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
-ur_result_t UR_APICALL urUsmP2PDisablePeerAccessExp(
-    ur_device_handle_t
-        commandDevice,            ///< [in] handle of the command device object
-    ur_device_handle_t peerDevice ///< [in] handle of the peer device object
-) {
+ur_result_t UR_APICALL
+urUsmP2PDisablePeerAccessExp(
+    ur_device_handle_t commandDevice,               ///< [in] handle of the command device object
+    ur_device_handle_t peerDevice                   ///< [in] handle of the peer device object
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Disable access to peer device memory
-///
+/// 
 /// @details
 ///     - Queries the peer access capabilities from the command device to the
 ///       peer device according to the query `propName`.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **cuDeviceGetP2PAttribute**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7959,29 +7793,28 @@ ur_result_t UR_APICALL urUsmP2PDisablePeerAccessExp(
 ///         + `pPropValue == NULL && pPropSizeRet == NULL`
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_ADAPTER_SPECIFIC
-ur_result_t UR_APICALL urUsmP2PPeerAccessGetInfoExp(
-    ur_device_handle_t
-        commandDevice,             ///< [in] handle of the command device object
-    ur_device_handle_t peerDevice, ///< [in] handle of the peer device object
-    ur_exp_peer_info_t propName,   ///< [in] type of the info to retrieve
-    size_t propSize, ///< [in] the number of bytes pointed to by pPropValue.
-    void *
-        pPropValue, ///< [out][optional][typename(propName, propSize)] array of bytes holding
-                    ///< the info.
-    ///< If propSize is not equal to or greater than the real number of bytes
-    ///< needed to return the info
-    ///< then the ::UR_RESULT_ERROR_INVALID_SIZE error is returned and
-    ///< pPropValue is not used.
-    size_t *
-        pPropSizeRet ///< [out][optional] pointer to the actual size in bytes of the queried propName.
-) {
+ur_result_t UR_APICALL
+urUsmP2PPeerAccessGetInfoExp(
+    ur_device_handle_t commandDevice,               ///< [in] handle of the command device object
+    ur_device_handle_t peerDevice,                  ///< [in] handle of the peer device object
+    ur_exp_peer_info_t propName,                    ///< [in] type of the info to retrieve
+    size_t propSize,                                ///< [in] the number of bytes pointed to by pPropValue.
+    void* pPropValue,                               ///< [out][optional][typename(propName, propSize)] array of bytes holding
+                                                    ///< the info.
+                                                    ///< If propSize is not equal to or greater than the real number of bytes
+                                                    ///< needed to return the info
+                                                    ///< then the ::UR_RESULT_ERROR_INVALID_SIZE error is returned and
+                                                    ///< pPropValue is not used.
+    size_t* pPropSizeRet                            ///< [out][optional] pointer to the actual size in bytes of the queried propName.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Immediately enqueue work through a native backend API
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7994,30 +7827,28 @@ ur_result_t UR_APICALL urUsmP2PPeerAccessGetInfoExp(
 ///     - ::UR_RESULT_ERROR_INVALID_ENUMERATION
 ///         + `NULL != pProperties && ::UR_EXP_ENQUEUE_NATIVE_COMMAND_FLAGS_MASK & pProperties->flags`
 ///     - ::UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST
-ur_result_t UR_APICALL urEnqueueNativeCommandExp(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    ur_exp_enqueue_native_command_function_t
-        pfnNativeEnqueue, ///< [in] function calling the native underlying API, to be executed
-                          ///< immediately.
-    void *data,                ///< [in][optional] data used by pfnNativeEnqueue
-    uint32_t numMemsInMemList, ///< [in] size of the mem list
-    const ur_mem_handle_t *
-        phMemList, ///< [in][optional][range(0, numMemsInMemList)] mems that are used within
-                   ///< pfnNativeEnqueue using ::urMemGetNativeHandle.
-    ///< If nullptr, the numMemsInMemList must be 0, indicating that no mems
-    ///< are accessed with ::urMemGetNativeHandle within pfnNativeEnqueue.
-    const ur_exp_enqueue_native_command_properties_t *
-        pProperties, ///< [in][optional] pointer to the native enqueue properties
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before the kernel execution.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating no wait events.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies the work that has
-    ///< been enqueued in nativeEnqueueFunc. If phEventWaitList and phEvent are
-    ///< not NULL, phEvent must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueNativeCommandExp(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    ur_exp_enqueue_native_command_function_t pfnNativeEnqueue,  ///< [in] function calling the native underlying API, to be executed
+                                                    ///< immediately.
+    void* data,                                     ///< [in][optional] data used by pfnNativeEnqueue
+    uint32_t numMemsInMemList,                      ///< [in] size of the mem list
+    const ur_mem_handle_t* phMemList,               ///< [in][optional][range(0, numMemsInMemList)] mems that are used within
+                                                    ///< pfnNativeEnqueue using ::urMemGetNativeHandle.
+                                                    ///< If nullptr, the numMemsInMemList must be 0, indicating that no mems
+                                                    ///< are accessed with ::urMemGetNativeHandle within pfnNativeEnqueue.
+    const ur_exp_enqueue_native_command_properties_t* pProperties,  ///< [in][optional] pointer to the native enqueue properties
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the kernel execution.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating no wait events.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies the work that has
+                                                    ///< been enqueued in nativeEnqueueFunc. If phEventWaitList and phEvent are
+                                                    ///< not NULL, phEvent must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }
+
diff --git a/test/conformance/enqueue/enqueue_adapter_cuda.match b/test/conformance/enqueue/enqueue_adapter_cuda.match
index 40de7158d0..de56dfa1f9 100644
--- a/test/conformance/enqueue/enqueue_adapter_cuda.match
+++ b/test/conformance/enqueue/enqueue_adapter_cuda.match
@@ -5,7 +5,7 @@ urEnqueueKernelLaunchKernelSubGroupTest.Success/NVIDIA_CUDA_BACKEND___{{.*}}_
 urEnqueueMemBufferMapTestWithWriteFlagParam.SuccessWrite/NVIDIA_CUDA_BACKEND___{{.*}}___UR_MAP_FLAG_WRITE_INVALIDATE_REGION
 urEnqueueUSMAdviseWithParamTest.Success/NVIDIA_CUDA_BACKEND___{{.*}}___UR_USM_ADVICE_FLAG_DEFAULT
 urEnqueueUSMAdviseTest.MultipleParamsSuccess/NVIDIA_CUDA_BACKEND___{{.*}}_
-urEnqueueUSMPrefetchWithParamTest.Success/NVIDIA_CUDA_BACKEND___{{.*}}___UR_USM_MIGRATION_FLAG_DEFAULT
-urEnqueueUSMPrefetchWithParamTest.CheckWaitEvent/NVIDIA_CUDA_BACKEND___{{.*}}___UR_USM_MIGRATION_FLAG_DEFAULT
+urEnqueueUSMPrefetchWithParamTest.Success/NVIDIA_CUDA_BACKEND___{{.*}}___UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE
+urEnqueueUSMPrefetchWithParamTest.CheckWaitEvent/NVIDIA_CUDA_BACKEND___{{.*}}___UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE
 urEnqueueTimestampRecordingExpTest.Success/NVIDIA_CUDA_BACKEND___{{.*}}_
 urEnqueueTimestampRecordingExpTest.SuccessBlocking/NVIDIA_CUDA_BACKEND___{{.*}}_
diff --git a/test/conformance/enqueue/urEnqueueUSMPrefetch.cpp b/test/conformance/enqueue/urEnqueueUSMPrefetch.cpp
index 2b0dbacb74..eeb54dfe58 100644
--- a/test/conformance/enqueue/urEnqueueUSMPrefetch.cpp
+++ b/test/conformance/enqueue/urEnqueueUSMPrefetch.cpp
@@ -9,7 +9,7 @@ using urEnqueueUSMPrefetchWithParamTest =
     uur::urUSMDeviceAllocTestWithParam<ur_usm_migration_flag_t>;
 
 UUR_TEST_SUITE_P(urEnqueueUSMPrefetchWithParamTest,
-                 ::testing::Values(UR_USM_MIGRATION_FLAG_DEFAULT),
+                 ::testing::Values(UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE),
                  uur::deviceTestWithParamPrinter<ur_usm_migration_flag_t>);
 
 TEST_P(urEnqueueUSMPrefetchWithParamTest, Success) {
@@ -77,14 +77,14 @@ UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEnqueueUSMPrefetchTest);
 TEST_P(urEnqueueUSMPrefetchTest, InvalidNullHandleQueue) {
     ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
                      urEnqueueUSMPrefetch(nullptr, ptr, allocation_size,
-                                          UR_USM_MIGRATION_FLAG_DEFAULT, 0,
+                                          UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE, 0,
                                           nullptr, nullptr));
 }
 
 TEST_P(urEnqueueUSMPrefetchTest, InvalidNullPointerMem) {
     ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
                      urEnqueueUSMPrefetch(queue, nullptr, allocation_size,
-                                          UR_USM_MIGRATION_FLAG_DEFAULT, 0,
+                                          UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE, 0,
                                           nullptr, nullptr));
 }
 
@@ -98,21 +98,21 @@ TEST_P(urEnqueueUSMPrefetchTest, InvalidEnumeration) {
 TEST_P(urEnqueueUSMPrefetchTest, InvalidSizeZero) {
     ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE,
                      urEnqueueUSMPrefetch(queue, ptr, 0,
-                                          UR_USM_MIGRATION_FLAG_DEFAULT, 0,
+                                          UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE, 0,
                                           nullptr, nullptr));
 }
 
 TEST_P(urEnqueueUSMPrefetchTest, InvalidSizeTooLarge) {
     ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE,
                      urEnqueueUSMPrefetch(queue, ptr, allocation_size * 2,
-                                          UR_USM_MIGRATION_FLAG_DEFAULT, 0,
+                                          UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE, 0,
                                           nullptr, nullptr));
 }
 
 TEST_P(urEnqueueUSMPrefetchTest, InvalidEventWaitList) {
     ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST,
                      urEnqueueUSMPrefetch(queue, ptr, allocation_size,
-                                          UR_USM_MIGRATION_FLAG_DEFAULT, 1,
+                                          UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE, 1,
                                           nullptr, nullptr));
 
     ur_event_handle_t validEvent;
@@ -120,12 +120,12 @@ TEST_P(urEnqueueUSMPrefetchTest, InvalidEventWaitList) {
 
     ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST,
                      urEnqueueUSMPrefetch(queue, ptr, allocation_size,
-                                          UR_USM_MIGRATION_FLAG_DEFAULT, 0,
+                                          UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE, 0,
                                           &validEvent, nullptr));
 
     ur_event_handle_t inv_evt = nullptr;
     ASSERT_EQ_RESULT(urEnqueueUSMPrefetch(queue, ptr, allocation_size,
-                                          UR_USM_MIGRATION_FLAG_DEFAULT, 1,
+                                          UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE, 1,
                                           &inv_evt, nullptr),
                      UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 

From ca43f937d91c53e04ebad69a02dbffdb1bc2f78e Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li@intel.com>
Date: Mon, 4 Nov 2024 16:03:42 -0800
Subject: [PATCH 02/20] CUDA: add migration flag logic

---
 source/adapters/cuda/enqueue.cpp | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/source/adapters/cuda/enqueue.cpp b/source/adapters/cuda/enqueue.cpp
index 0e00f680f6..d9ba784530 100644
--- a/source/adapters/cuda/enqueue.cpp
+++ b/source/adapters/cuda/enqueue.cpp
@@ -1559,13 +1559,21 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
     ur_queue_handle_t hQueue, const void *pMem, size_t size,
     ur_usm_migration_flags_t flags, uint32_t numEventsInWaitList,
     const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent) {
-  std::ignore = flags;
+  ur_device_handle_t Device = hQueue->getDevice();
+  CUdevice TargetDevice;
+  if (flags == UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE) {
+    TargetDevice = Device->get();
+  } else if (flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) {
+    TargetDevice = CU_DEVICE_CPU;
+  } else {
+    setErrorMessage("Invalid USM migration flag", UR_RESULT_ERROR_INVALID_ENUMERATION);
+    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+  }
 
   size_t PointerRangeSize = 0;
   UR_CHECK_ERROR(cuPointerGetAttribute(
       &PointerRangeSize, CU_POINTER_ATTRIBUTE_RANGE_SIZE, (CUdeviceptr)pMem));
   UR_ASSERT(size <= PointerRangeSize, UR_RESULT_ERROR_INVALID_SIZE);
-  ur_device_handle_t Device = hQueue->getDevice();
 
   // Certain cuda devices and Windows do not have support for some Unified
   // Memory features. cuMemPrefetchAsync requires concurrent memory access
@@ -1602,7 +1610,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
       UR_CHECK_ERROR(EventPtr->start());
     }
     UR_CHECK_ERROR(
-        cuMemPrefetchAsync((CUdeviceptr)pMem, size, Device->get(), CuStream));
+        cuMemPrefetchAsync((CUdeviceptr)pMem, size, TargetDevice, CuStream));
     if (phEvent) {
       UR_CHECK_ERROR(EventPtr->record());
       *phEvent = EventPtr.release();

From 90110bf8b874b2c35074e45f37f1942df47a7a1d Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li@intel.com>
Date: Fri, 8 Nov 2024 15:16:59 -0800
Subject: [PATCH 03/20] add preliminary testing -- BROKEN MATCH

---
 test/conformance/enqueue/enqueue_adapter_cuda.match | 4 ++--
 test/conformance/enqueue/urEnqueueUSMPrefetch.cpp   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/conformance/enqueue/enqueue_adapter_cuda.match b/test/conformance/enqueue/enqueue_adapter_cuda.match
index de56dfa1f9..d8d7fbfec8 100644
--- a/test/conformance/enqueue/enqueue_adapter_cuda.match
+++ b/test/conformance/enqueue/enqueue_adapter_cuda.match
@@ -5,7 +5,7 @@ urEnqueueKernelLaunchKernelSubGroupTest.Success/NVIDIA_CUDA_BACKEND___{{.*}}_
 urEnqueueMemBufferMapTestWithWriteFlagParam.SuccessWrite/NVIDIA_CUDA_BACKEND___{{.*}}___UR_MAP_FLAG_WRITE_INVALIDATE_REGION
 urEnqueueUSMAdviseWithParamTest.Success/NVIDIA_CUDA_BACKEND___{{.*}}___UR_USM_ADVICE_FLAG_DEFAULT
 urEnqueueUSMAdviseTest.MultipleParamsSuccess/NVIDIA_CUDA_BACKEND___{{.*}}_
-urEnqueueUSMPrefetchWithParamTest.Success/NVIDIA_CUDA_BACKEND___{{.*}}___UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE
-urEnqueueUSMPrefetchWithParamTest.CheckWaitEvent/NVIDIA_CUDA_BACKEND___{{.*}}___UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE
+urEnqueueUSMPrefetchWithParamTest.Success/NVIDIA_CUDA_BACKEND___{{.*}}___UR_USM_MIGRATION_FLAG_{{.*}}
+urEnqueueUSMPrefetchWithParamTest.CheckWaitEvent/NVIDIA_CUDA_BACKEND___{{.*}}___UR_USM_MIGRATION_FLAG_{{.*}}
 urEnqueueTimestampRecordingExpTest.Success/NVIDIA_CUDA_BACKEND___{{.*}}_
 urEnqueueTimestampRecordingExpTest.SuccessBlocking/NVIDIA_CUDA_BACKEND___{{.*}}_
diff --git a/test/conformance/enqueue/urEnqueueUSMPrefetch.cpp b/test/conformance/enqueue/urEnqueueUSMPrefetch.cpp
index eeb54dfe58..d0d6d507fd 100644
--- a/test/conformance/enqueue/urEnqueueUSMPrefetch.cpp
+++ b/test/conformance/enqueue/urEnqueueUSMPrefetch.cpp
@@ -9,7 +9,7 @@ using urEnqueueUSMPrefetchWithParamTest =
     uur::urUSMDeviceAllocTestWithParam<ur_usm_migration_flag_t>;
 
 UUR_TEST_SUITE_P(urEnqueueUSMPrefetchWithParamTest,
-                 ::testing::Values(UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE),
+                 ::testing::Values(UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE, UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST),
                  uur::deviceTestWithParamPrinter<ur_usm_migration_flag_t>);
 
 TEST_P(urEnqueueUSMPrefetchWithParamTest, Success) {

From fceb1a75878c6d6030130b9cbe9cb44a03e980d2 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li@intel.com>
Date: Mon, 11 Nov 2024 15:30:27 -0800
Subject: [PATCH 04/20] Fix CUDA conformance enqueue match patterns

---
 test/conformance/enqueue/enqueue_adapter_cuda.match | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/test/conformance/enqueue/enqueue_adapter_cuda.match b/test/conformance/enqueue/enqueue_adapter_cuda.match
index d8d7fbfec8..9ad8c48fd5 100644
--- a/test/conformance/enqueue/enqueue_adapter_cuda.match
+++ b/test/conformance/enqueue/enqueue_adapter_cuda.match
@@ -5,7 +5,9 @@ urEnqueueKernelLaunchKernelSubGroupTest.Success/NVIDIA_CUDA_BACKEND___{{.*}}_
 urEnqueueMemBufferMapTestWithWriteFlagParam.SuccessWrite/NVIDIA_CUDA_BACKEND___{{.*}}___UR_MAP_FLAG_WRITE_INVALIDATE_REGION
 urEnqueueUSMAdviseWithParamTest.Success/NVIDIA_CUDA_BACKEND___{{.*}}___UR_USM_ADVICE_FLAG_DEFAULT
 urEnqueueUSMAdviseTest.MultipleParamsSuccess/NVIDIA_CUDA_BACKEND___{{.*}}_
-urEnqueueUSMPrefetchWithParamTest.Success/NVIDIA_CUDA_BACKEND___{{.*}}___UR_USM_MIGRATION_FLAG_{{.*}}
-urEnqueueUSMPrefetchWithParamTest.CheckWaitEvent/NVIDIA_CUDA_BACKEND___{{.*}}___UR_USM_MIGRATION_FLAG_{{.*}}
+urEnqueueUSMPrefetchWithParamTest.Success/NVIDIA_CUDA_BACKEND___{{.*}}___UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE
+urEnqueueUSMPrefetchWithParamTest.Success/NVIDIA_CUDA_BACKEND___{{.*}}___UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST
+urEnqueueUSMPrefetchWithParamTest.CheckWaitEvent/NVIDIA_CUDA_BACKEND___{{.*}}___UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE
+urEnqueueUSMPrefetchWithParamTest.CheckWaitEvent/NVIDIA_CUDA_BACKEND___{{.*}}___UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST
 urEnqueueTimestampRecordingExpTest.Success/NVIDIA_CUDA_BACKEND___{{.*}}_
 urEnqueueTimestampRecordingExpTest.SuccessBlocking/NVIDIA_CUDA_BACKEND___{{.*}}_

From 8cfd770976e9da7256deaedfd30ba14f28841e29 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li@intel.com>
Date: Wed, 13 Nov 2024 11:29:27 -0800
Subject: [PATCH 05/20] Add hip adapter for urEnqueueUSMPrefetch

---
 source/adapters/hip/enqueue.cpp | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/source/adapters/hip/enqueue.cpp b/source/adapters/hip/enqueue.cpp
index 293f3eea7a..c536bdd08f 100644
--- a/source/adapters/hip/enqueue.cpp
+++ b/source/adapters/hip/enqueue.cpp
@@ -1316,10 +1316,20 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
     ur_queue_handle_t hQueue, const void *pMem, size_t size,
     ur_usm_migration_flags_t flags, uint32_t numEventsInWaitList,
     const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent) {
-  std::ignore = flags;
 
   void *HIPDevicePtr = const_cast<void *>(pMem);
   ur_device_handle_t Device = hQueue->getDevice();
+  hipDevice_t TargetDevice;
+  if (flags == UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE) {
+    TargetDevice = Device->get();
+  } else if (flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) {
+    // HIP doesn't have a constant for host like CUDA does; -1 is used instead
+    // https://github.com/ROCm/HIP/blob/3d60bd3a6415c2/docs/how-to/unified_memory.rst#L376
+    TargetDevice = -1;
+  } else {
+    setErrorMessage("Invalid USM migration flag", UR_RESULT_ERROR_INVALID_ENUMERATION);
+    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+  }
 
 // HIP_POINTER_ATTRIBUTE_RANGE_SIZE is not an attribute in ROCM < 5,
 // so we can't perform this check for such cases.
@@ -1380,7 +1390,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
     }
 
     UR_CHECK_ERROR(
-        hipMemPrefetchAsync(pMem, size, hQueue->getDevice()->get(), HIPStream));
+        hipMemPrefetchAsync(pMem, size, TargetDevice, HIPStream));
     releaseEvent();
   } catch (ur_result_t Err) {
     return Err;

From fb02dacf979036236cd047f115ef4e0058b09db6 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li@intel.com>
Date: Wed, 13 Nov 2024 14:34:34 -0800
Subject: [PATCH 06/20] Fix migration_flags yml spec

---
 scripts/core/enqueue.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/core/enqueue.yml b/scripts/core/enqueue.yml
index 575dbaebf3..ee54d23aaf 100644
--- a/scripts/core/enqueue.yml
+++ b/scripts/core/enqueue.yml
@@ -848,7 +848,7 @@ etors:
 --- #--------------------------------------------------------------------------
 type: enum
 desc: "USM migration flags, indicating the direction data is migrated in"
-class: $xDevice
+class: $xEnqueue
 name: $x_usm_migration_flags_t
 etors:
     - name: HOST_TO_DEVICE

From a502a6ee901d9b767da06c4e12f23475752a15a7 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li@intel.com>
Date: Tue, 19 Nov 2024 13:18:26 -0800
Subject: [PATCH 07/20] Re-enable cl usm prefetch

---
 include/ur_print.h             |  6 +++---
 source/adapters/opencl/usm.cpp | 11 ++++------
 source/ur_api.cpp              | 37 +++++++++++++++++-----------------
 3 files changed, 25 insertions(+), 29 deletions(-)

diff --git a/include/ur_print.h b/include/ur_print.h
index 5de0f75c59..de8134b2ac 100644
--- a/include/ur_print.h
+++ b/include/ur_print.h
@@ -1065,7 +1065,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpPeerInfo(enum ur_exp_peer_info_t v
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpEnqueueExtFlags(enum ur_exp_enqueue_ext_flag_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpEnqueueExtFlags(enum ur_exp_enqueue_ext_flag_t value, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_enqueue_ext_properties_t struct
@@ -1073,7 +1073,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpEnqueueExtFlags(enum ur_exp_enqueu
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpEnqueueExtProperties(const struct ur_exp_enqueue_ext_properties_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpEnqueueExtProperties(const struct ur_exp_enqueue_ext_properties_t params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_enqueue_native_command_flag_t enum
@@ -2057,7 +2057,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueKernelLaunchCustomExpParams(co
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueEventsWaitWithBarrierExtParams(const struct ur_enqueue_events_wait_with_barrier_ext_params_t *params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintEnqueueEventsWaitWithBarrierExtParams(const struct ur_enqueue_events_wait_with_barrier_ext_params_t * params, char * buffer, const size_t buff_size, size_t * out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_enqueue_cooperative_kernel_launch_exp_params_t struct
diff --git a/source/adapters/opencl/usm.cpp b/source/adapters/opencl/usm.cpp
index dfcc1dfafa..ccaf182d8b 100644
--- a/source/adapters/opencl/usm.cpp
+++ b/source/adapters/opencl/usm.cpp
@@ -493,13 +493,11 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
     uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
     ur_event_handle_t *phEvent) {
 
-  return mapCLErrorToUR(clEnqueueMarkerWithWaitList(
-      cl_adapter::cast<cl_command_queue>(hQueue), numEventsInWaitList,
-      cl_adapter::cast<const cl_event *>(phEventWaitList),
-      cl_adapter::cast<cl_event *>(phEvent)));
+  //return mapCLErrorToUR(clEnqueueMarkerWithWaitList(
+  //    cl_adapter::cast<cl_command_queue>(hQueue), numEventsInWaitList,
+  //    cl_adapter::cast<const cl_event *>(phEventWaitList),
+  //    cl_adapter::cast<cl_event *>(phEvent)));
 
-  /*
-  // Use this once impls support it.
   // Have to look up the context from the kernel
   cl_context CLContext;
   cl_int CLErr =
@@ -524,7 +522,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
                 reinterpret_cast<const cl_event *>(phEventWaitList),
                 reinterpret_cast<cl_event *>(phEvent)));
   }
-  */
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMAdvise(
diff --git a/source/ur_api.cpp b/source/ur_api.cpp
index 952d228c50..ac8698777f 100644
--- a/source/ur_api.cpp
+++ b/source/ur_api.cpp
@@ -7836,18 +7836,18 @@ urUsmP2PPeerAccessGetInfoExp(
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Enqueue a barrier command which waits a list of events to complete
 ///        before it completes, with optional extended properties
-///
+/// 
 /// @details
 ///     - If the event list is empty, it waits for all previously enqueued
 ///       commands to complete.
 ///     - It blocks command execution - any following commands enqueued after it
 ///       do not execute until it completes.
 ///     - It returns an event which can be waited on.
-///
+/// 
 /// @remarks
 ///   _Analogues_
 ///     - **clEnqueueBarrierWithWaitList**
-///
+/// 
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
@@ -7868,22 +7868,21 @@ urUsmP2PPeerAccessGetInfoExp(
 ///     - ::UR_RESULT_ERROR_INVALID_VALUE
 ///     - ::UR_RESULT_ERROR_OUT_OF_HOST_MEMORY
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
-ur_result_t UR_APICALL urEnqueueEventsWaitWithBarrierExt(
-    ur_queue_handle_t hQueue, ///< [in] handle of the queue object
-    const ur_exp_enqueue_ext_properties_t *
-        pProperties, ///< [in][optional] pointer to the extended enqueue properties
-    uint32_t numEventsInWaitList, ///< [in] size of the event wait list
-    const ur_event_handle_t *
-        phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-    ///< events that must be complete before this command can be executed.
-    ///< If nullptr, the numEventsInWaitList must be 0, indicating that all
-    ///< previously enqueued commands
-    ///< must be complete.
-    ur_event_handle_t *
-        phEvent ///< [out][optional] return an event object that identifies this particular
-    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
-    ///< must not refer to an element of the phEventWaitList array.
-) {
+ur_result_t UR_APICALL
+urEnqueueEventsWaitWithBarrierExt(
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    const ur_exp_enqueue_ext_properties_t* pProperties, ///< [in][optional] pointer to the extended enqueue properties
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t* phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before this command can be executed.
+                                                    ///< If nullptr, the numEventsInWaitList must be 0, indicating that all
+                                                    ///< previously enqueued commands
+                                                    ///< must be complete.
+    ur_event_handle_t* phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< command instance. If phEventWaitList and phEvent are not NULL, phEvent
+                                                    ///< must not refer to an element of the phEventWaitList array.
+    )
+{
     ur_result_t result = UR_RESULT_SUCCESS;
     return result;
 }

From 8cd3d7c13e0065e5c03fd4018e1433a947a1e56d Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li@intel.com>
Date: Wed, 20 Nov 2024 11:44:33 -0800
Subject: [PATCH 08/20] redisable opencl prefetch

---
 source/adapters/opencl/usm.cpp | 70 ++++++++++++++++++++--------------
 1 file changed, 41 insertions(+), 29 deletions(-)

diff --git a/source/adapters/opencl/usm.cpp b/source/adapters/opencl/usm.cpp
index ccaf182d8b..2892256967 100644
--- a/source/adapters/opencl/usm.cpp
+++ b/source/adapters/opencl/usm.cpp
@@ -493,35 +493,47 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
     uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
     ur_event_handle_t *phEvent) {
 
-  //return mapCLErrorToUR(clEnqueueMarkerWithWaitList(
-  //    cl_adapter::cast<cl_command_queue>(hQueue), numEventsInWaitList,
-  //    cl_adapter::cast<const cl_event *>(phEventWaitList),
-  //    cl_adapter::cast<cl_event *>(phEvent)));
-
-  // Have to look up the context from the kernel
-  cl_context CLContext;
-  cl_int CLErr =
-  clGetCommandQueueInfo(cl_adapter::cast<cl_command_queue>(hQueue),
-                                       CL_QUEUE_CONTEXT, sizeof(cl_context),
-                                       &CLContext, nullptr);
-  if (CLErr != CL_SUCCESS) {
-    return map_cl_error_to_ur(CLErr);
-  }
-
-  clEnqueueMigrateMemINTEL_fn FuncPtr;
-  ur_result_t Err = cl_ext::getExtFuncFromContext<clEnqueueMigrateMemINTEL_fn>(
-      CLContext, "clEnqueueMigrateMemINTEL", &FuncPtr);
-
-  ur_result_t RetVal;
-  if (Err != UR_RESULT_SUCCESS) {
-    RetVal = Err;
-  } else {
-    RetVal = map_cl_error_to_ur(
-        FuncPtr(cl_adapter::cast<cl_command_queue>(hQueue), pMem, size, flags,
-                numEventsInWaitList,
-                reinterpret_cast<const cl_event *>(phEventWaitList),
-                reinterpret_cast<cl_event *>(phEvent)));
-  }
+  return mapCLErrorToUR(clEnqueueMarkerWithWaitList(
+      cl_adapter::cast<cl_command_queue>(hQueue), numEventsInWaitList,
+      cl_adapter::cast<const cl_event *>(phEventWaitList),
+      cl_adapter::cast<cl_event *>(phEvent)));
+
+  // cl_mem_migration_flags MigrationFlag;
+  // if (flags == UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE) {
+  //   MigrationFlag = CL_MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED;
+  // } else if (flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) {
+  //   MigrationFlag = CL_MIGRATE_MEM_OBJECT_HOST;
+  // } else {
+  //   return UR_RESULT_ERROR_INVALID_ENUMERATION;
+  // }
+
+  // // Have to look up the context from the kernel
+  // cl_context CLContext;
+  // cl_int CLErr =
+  // clGetCommandQueueInfo(cl_adapter::cast<cl_command_queue>(hQueue),
+  //                                      CL_QUEUE_CONTEXT, sizeof(cl_context),
+  //                                      &CLContext, nullptr);
+  // if (CLErr != CL_SUCCESS) {
+  //   return map_cl_error_to_ur(CLErr);
+  // }
+
+  // clEnqueueMigrateMemINTEL_fn FuncPtr;
+  // ur_result_t Err = cl_ext::getExtFuncFromContext<clEnqueueMigrateMemINTEL_fn>(
+  //     CLContext, "clEnqueueMigrateMemINTEL", &FuncPtr);
+  //     // cl_ext::getExtFuncFromContext<clHostMemAllocINTEL_fn>(
+  //     // CLContext, cl_ext::ExtFuncPtrCache->clHostMemAllocINTELCache,
+  //     // cl_ext::HostMemAllocName, &HostMemAlloc)
+
+  // ur_result_t RetVal;
+  // if (Err != UR_RESULT_SUCCESS) {
+  //   RetVal = Err;
+  // } else {
+  //   RetVal = map_cl_error_to_ur(
+  //       FuncPtr(cl_adapter::cast<cl_command_queue>(hQueue), pMem, size,
+  //               MigrationFlag, numEventsInWaitList,
+  //               reinterpret_cast<const cl_event *>(phEventWaitList),
+  //               reinterpret_cast<cl_event *>(phEvent)));
+  // }
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMAdvise(

From 37b7fa7bfc0a320fb466fdcd82565cf626272eef Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li@intel.com>
Date: Thu, 21 Nov 2024 12:43:00 -0800
Subject: [PATCH 09/20] Rewrite OCL urEnqueueUSMPrefetch

---
 source/adapters/opencl/common.hpp             |  2 +
 .../adapters/opencl/extension_functions.def   |  1 +
 source/adapters/opencl/usm.cpp                | 82 +++++++++----------
 3 files changed, 44 insertions(+), 41 deletions(-)

diff --git a/source/adapters/opencl/common.hpp b/source/adapters/opencl/common.hpp
index 95fc57319d..07abe167ad 100644
--- a/source/adapters/opencl/common.hpp
+++ b/source/adapters/opencl/common.hpp
@@ -203,6 +203,7 @@ CONSTFIX char EnqueueWriteGlobalVariableName[] =
     "clEnqueueWriteGlobalVariableINTEL";
 CONSTFIX char EnqueueReadGlobalVariableName[] =
     "clEnqueueReadGlobalVariableINTEL";
+CONSTFIX char EnqueueMigrateMemName[] = "clEnqueueMigrateMemINTEL";
 // Names of host pipe functions queried from OpenCL
 CONSTFIX char EnqueueReadHostPipeName[] = "clEnqueueReadHostPipeINTEL";
 CONSTFIX char EnqueueWriteHostPipeName[] = "clEnqueueWriteHostPipeINTEL";
@@ -220,6 +221,7 @@ CONSTFIX char GetCommandBufferInfoName[] = "clGetCommandBufferInfoKHR";
 CONSTFIX char UpdateMutableCommandsName[] = "clUpdateMutableCommandsKHR";
 CONSTFIX char CreateProgramWithILName[] = "clCreateProgramWithILKHR";
 CONSTFIX char GetKernelSubGroupInfoName[] = "clGetKernelSubGroupInfoKHR";
+CONSTFIX char GetKernelSubGroupInfoName[] = "clGetKernelSubGroupInfoKHR";
 
 #undef CONSTFIX
 
diff --git a/source/adapters/opencl/extension_functions.def b/source/adapters/opencl/extension_functions.def
index 3f5e3ea917..490dbebad3 100644
--- a/source/adapters/opencl/extension_functions.def
+++ b/source/adapters/opencl/extension_functions.def
@@ -13,6 +13,7 @@ CL_EXTENSION_FUNC(clEnqueueWriteGlobalVariable)
 CL_EXTENSION_FUNC(clEnqueueReadGlobalVariable)
 CL_EXTENSION_FUNC(clEnqueueReadHostPipeINTEL)
 CL_EXTENSION_FUNC(clEnqueueWriteHostPipeINTEL)
+CL_EXTENSION_FUNC(clEnqueueMigrateMemINTEL)
 CL_EXTENSION_FUNC(clCreateCommandBufferKHR)
 CL_EXTENSION_FUNC(clRetainCommandBufferKHR)
 CL_EXTENSION_FUNC(clReleaseCommandBufferKHR)
diff --git a/source/adapters/opencl/usm.cpp b/source/adapters/opencl/usm.cpp
index 2892256967..bb4dff5e41 100644
--- a/source/adapters/opencl/usm.cpp
+++ b/source/adapters/opencl/usm.cpp
@@ -493,47 +493,47 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
     uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
     ur_event_handle_t *phEvent) {
 
-  return mapCLErrorToUR(clEnqueueMarkerWithWaitList(
-      cl_adapter::cast<cl_command_queue>(hQueue), numEventsInWaitList,
-      cl_adapter::cast<const cl_event *>(phEventWaitList),
-      cl_adapter::cast<cl_event *>(phEvent)));
-
-  // cl_mem_migration_flags MigrationFlag;
-  // if (flags == UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE) {
-  //   MigrationFlag = CL_MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED;
-  // } else if (flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) {
-  //   MigrationFlag = CL_MIGRATE_MEM_OBJECT_HOST;
-  // } else {
-  //   return UR_RESULT_ERROR_INVALID_ENUMERATION;
-  // }
-
-  // // Have to look up the context from the kernel
-  // cl_context CLContext;
-  // cl_int CLErr =
-  // clGetCommandQueueInfo(cl_adapter::cast<cl_command_queue>(hQueue),
-  //                                      CL_QUEUE_CONTEXT, sizeof(cl_context),
-  //                                      &CLContext, nullptr);
-  // if (CLErr != CL_SUCCESS) {
-  //   return map_cl_error_to_ur(CLErr);
-  // }
-
-  // clEnqueueMigrateMemINTEL_fn FuncPtr;
-  // ur_result_t Err = cl_ext::getExtFuncFromContext<clEnqueueMigrateMemINTEL_fn>(
-  //     CLContext, "clEnqueueMigrateMemINTEL", &FuncPtr);
-  //     // cl_ext::getExtFuncFromContext<clHostMemAllocINTEL_fn>(
-  //     // CLContext, cl_ext::ExtFuncPtrCache->clHostMemAllocINTELCache,
-  //     // cl_ext::HostMemAllocName, &HostMemAlloc)
-
-  // ur_result_t RetVal;
-  // if (Err != UR_RESULT_SUCCESS) {
-  //   RetVal = Err;
-  // } else {
-  //   RetVal = map_cl_error_to_ur(
-  //       FuncPtr(cl_adapter::cast<cl_command_queue>(hQueue), pMem, size,
-  //               MigrationFlag, numEventsInWaitList,
-  //               reinterpret_cast<const cl_event *>(phEventWaitList),
-  //               reinterpret_cast<cl_event *>(phEvent)));
-  // }
+  // return mapCLErrorToUR(clEnqueueMarkerWithWaitList(
+  //     cl_adapter::cast<cl_command_queue>(hQueue), numEventsInWaitList,
+  //     cl_adapter::cast<const cl_event *>(phEventWaitList),
+  //     cl_adapter::cast<cl_event *>(phEvent)));
+
+
+  cl_mem_migration_flags MigrationFlag;
+  if (flags == UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE) {
+    MigrationFlag = CL_MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED;
+  } else if (flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) {
+    MigrationFlag = CL_MIGRATE_MEM_OBJECT_HOST;
+  } else {
+    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+  }
+
+  // Have to look up the context from the kernel
+  cl_context CLContext;
+  cl_int CLErr =
+  clGetCommandQueueInfo(cl_adapter::cast<cl_command_queue>(hQueue),
+                                       CL_QUEUE_CONTEXT, sizeof(cl_context),
+                                       &CLContext, nullptr);
+  if (CLErr != CL_SUCCESS) {
+    return map_cl_error_to_ur(CLErr);
+  }
+
+  clEnqueueMigrateMemINTEL_fn FuncPtr;
+  if (cl_ext::getExtFuncFromContext<clEnqueueMigrateMemINTEL_fn>(
+      CLContext, cl_ext::ExtFuncPtrCache->clEnqueueMigrateMemINTELCache,
+      cl_ext::EnqueueMigrateMemName, &FuncPtr)) {
+    // Exit gracefully if unable to find USM function
+    return UR_RESULT_SUCCESS;
+  }
+      // cl_ext::getExtFuncFromContext<clHostMemAllocINTEL_fn>(
+      // CLContext, cl_ext::ExtFuncPtrCache->clHostMemAllocINTELCache,
+      // cl_ext::HostMemAllocName, &HostMemAlloc)
+
+  return mapCLErrorToUR(
+      FuncPtr(cl_adapter::cast<cl_command_queue>(hQueue), pMem, size,
+              MigrationFlag, numEventsInWaitList,
+              reinterpret_cast<const cl_event *>(phEventWaitList),
+              reinterpret_cast<cl_event *>(phEvent)));
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMAdvise(

From 4dca8166ffd212e7ed323fbde9e9458c152aa3ec Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li@intel.com>
Date: Thu, 21 Nov 2024 13:37:09 -0800
Subject: [PATCH 10/20] Add warnings, fix bug with legacy mapCLErrorToUR

---
 source/adapters/opencl/usm.cpp | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/source/adapters/opencl/usm.cpp b/source/adapters/opencl/usm.cpp
index bb4dff5e41..293bee050a 100644
--- a/source/adapters/opencl/usm.cpp
+++ b/source/adapters/opencl/usm.cpp
@@ -499,15 +499,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
   //     cl_adapter::cast<cl_event *>(phEvent)));
 
 
-  cl_mem_migration_flags MigrationFlag;
-  if (flags == UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE) {
-    MigrationFlag = CL_MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED;
-  } else if (flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) {
-    MigrationFlag = CL_MIGRATE_MEM_OBJECT_HOST;
-  } else {
-    return UR_RESULT_ERROR_INVALID_ENUMERATION;
-  }
-
   // Have to look up the context from the kernel
   cl_context CLContext;
   cl_int CLErr =
@@ -515,7 +506,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
                                        CL_QUEUE_CONTEXT, sizeof(cl_context),
                                        &CLContext, nullptr);
   if (CLErr != CL_SUCCESS) {
-    return map_cl_error_to_ur(CLErr);
+    return mapCLErrorToUR(CLErr);
   }
 
   clEnqueueMigrateMemINTEL_fn FuncPtr;
@@ -523,12 +514,22 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
       CLContext, cl_ext::ExtFuncPtrCache->clEnqueueMigrateMemINTELCache,
       cl_ext::EnqueueMigrateMemName, &FuncPtr)) {
     // Exit gracefully if unable to find USM function
+    setErrorMessage("Prefetch hint ignored as current OpenCL version does not support clEnqueueMigrateMemINTEL", UR_RESULT_SUCCESS);
     return UR_RESULT_SUCCESS;
   }
       // cl_ext::getExtFuncFromContext<clHostMemAllocINTEL_fn>(
       // CLContext, cl_ext::ExtFuncPtrCache->clHostMemAllocINTELCache,
       // cl_ext::HostMemAllocName, &HostMemAlloc)
 
+  cl_mem_migration_flags MigrationFlag;
+  if (flags == UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE) {
+    MigrationFlag = CL_MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED;
+  } else if (flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) {
+    MigrationFlag = CL_MIGRATE_MEM_OBJECT_HOST;
+  } else {
+    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+  }
+
   return mapCLErrorToUR(
       FuncPtr(cl_adapter::cast<cl_command_queue>(hQueue), pMem, size,
               MigrationFlag, numEventsInWaitList,

From 5811a5b2c2646499f291e0186f2ca7075b7314cb Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li@intel.com>
Date: Fri, 22 Nov 2024 08:50:57 -0800
Subject: [PATCH 11/20] Remove duplicate line

---
 source/adapters/opencl/common.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/source/adapters/opencl/common.hpp b/source/adapters/opencl/common.hpp
index 07abe167ad..53c508a48a 100644
--- a/source/adapters/opencl/common.hpp
+++ b/source/adapters/opencl/common.hpp
@@ -221,7 +221,6 @@ CONSTFIX char GetCommandBufferInfoName[] = "clGetCommandBufferInfoKHR";
 CONSTFIX char UpdateMutableCommandsName[] = "clUpdateMutableCommandsKHR";
 CONSTFIX char CreateProgramWithILName[] = "clCreateProgramWithILKHR";
 CONSTFIX char GetKernelSubGroupInfoName[] = "clGetKernelSubGroupInfoKHR";
-CONSTFIX char GetKernelSubGroupInfoName[] = "clGetKernelSubGroupInfoKHR";
 
 #undef CONSTFIX
 

From bec723bdcd3caf01d46da51395ba35b364dd9354 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li@intel.com>
Date: Fri, 22 Nov 2024 08:52:12 -0800
Subject: [PATCH 12/20] Remove duplicate line

---
 source/adapters/opencl/usm.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/adapters/opencl/usm.cpp b/source/adapters/opencl/usm.cpp
index 293bee050a..91d641a27e 100644
--- a/source/adapters/opencl/usm.cpp
+++ b/source/adapters/opencl/usm.cpp
@@ -514,7 +514,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
       CLContext, cl_ext::ExtFuncPtrCache->clEnqueueMigrateMemINTELCache,
       cl_ext::EnqueueMigrateMemName, &FuncPtr)) {
     // Exit gracefully if unable to find USM function
-    setErrorMessage("Prefetch hint ignored as current OpenCL version does not support clEnqueueMigrateMemINTEL", UR_RESULT_SUCCESS);
+    cl_adapter::setErrorMessage("Prefetch hint ignored as current OpenCL version does not support clEnqueueMigrateMemINTEL", UR_RESULT_SUCCESS);
     return UR_RESULT_SUCCESS;
   }
       // cl_ext::getExtFuncFromContext<clHostMemAllocINTEL_fn>(

From 283dffb79d7d860de52ef520d98b2de32dfd7507 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li@intel.com>
Date: Tue, 3 Dec 2024 15:15:34 -0800
Subject: [PATCH 13/20] Fix ctest errors

---
 source/adapters/opencl/common.cpp             |  4 +--
 source/adapters/opencl/common.hpp             |  5 ++-
 .../adapters/opencl/extension_functions.def   |  2 +-
 source/adapters/opencl/usm.cpp                | 36 +++++++++----------
 .../enqueue/urEnqueueUSMPrefetch.cpp          |  6 ++++
 5 files changed, 27 insertions(+), 26 deletions(-)

diff --git a/source/adapters/opencl/common.cpp b/source/adapters/opencl/common.cpp
index d6e934c68b..abdb9bc8c7 100644
--- a/source/adapters/opencl/common.cpp
+++ b/source/adapters/opencl/common.cpp
@@ -13,10 +13,10 @@
 namespace cl_adapter {
 
 /* Global variables for urAdapterGetLastError() */
-thread_local int32_t ErrorMessageCode = 0;
+thread_local ur_result_t ErrorMessageCode = UR_RESULT_SUCCESS;
 thread_local char ErrorMessage[MaxMessageSize];
 
-[[maybe_unused]] void setErrorMessage(const char *Message, int32_t ErrorCode) {
+[[maybe_unused]] void setErrorMessage(const char *Message, ur_result_t ErrorCode) {
   assert(strlen(Message) <= cl_adapter::MaxMessageSize);
   strcpy(cl_adapter::ErrorMessage, Message);
   ErrorMessageCode = ErrorCode;
diff --git a/source/adapters/opencl/common.hpp b/source/adapters/opencl/common.hpp
index 53c508a48a..c7b774428b 100644
--- a/source/adapters/opencl/common.hpp
+++ b/source/adapters/opencl/common.hpp
@@ -150,12 +150,11 @@ inline const OpenCLVersion V3_0(3, 0);
 
 namespace cl_adapter {
 constexpr size_t MaxMessageSize = 256;
-extern thread_local int32_t ErrorMessageCode;
+extern thread_local ur_result_t ErrorMessageCode;
 extern thread_local char ErrorMessage[MaxMessageSize];
 
 // Utility function for setting a message and warning
-[[maybe_unused]] void setErrorMessage(const char *Message,
-                                      ur_result_t ErrorCode);
+[[maybe_unused]] void setErrorMessage(const char *Message, ur_result_t ErrorCode);
 
 [[noreturn]] void die(const char *Message);
 
diff --git a/source/adapters/opencl/extension_functions.def b/source/adapters/opencl/extension_functions.def
index 490dbebad3..e947407cbc 100644
--- a/source/adapters/opencl/extension_functions.def
+++ b/source/adapters/opencl/extension_functions.def
@@ -8,12 +8,12 @@ CL_EXTENSION_FUNC(clMemBlockingFreeINTEL)
 CL_EXTENSION_FUNC(clSetKernelArgMemPointerINTEL)
 CL_EXTENSION_FUNC(clEnqueueMemFillINTEL)
 CL_EXTENSION_FUNC(clEnqueueMemcpyINTEL)
+CL_EXTENSION_FUNC(clEnqueueMigrateMemINTEL)
 CL_EXTENSION_FUNC(clGetMemAllocInfoINTEL)
 CL_EXTENSION_FUNC(clEnqueueWriteGlobalVariable)
 CL_EXTENSION_FUNC(clEnqueueReadGlobalVariable)
 CL_EXTENSION_FUNC(clEnqueueReadHostPipeINTEL)
 CL_EXTENSION_FUNC(clEnqueueWriteHostPipeINTEL)
-CL_EXTENSION_FUNC(clEnqueueMigrateMemINTEL)
 CL_EXTENSION_FUNC(clCreateCommandBufferKHR)
 CL_EXTENSION_FUNC(clRetainCommandBufferKHR)
 CL_EXTENSION_FUNC(clReleaseCommandBufferKHR)
diff --git a/source/adapters/opencl/usm.cpp b/source/adapters/opencl/usm.cpp
index 91d641a27e..66f694cb82 100644
--- a/source/adapters/opencl/usm.cpp
+++ b/source/adapters/opencl/usm.cpp
@@ -489,22 +489,16 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMMemcpy(
 UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
     ur_queue_handle_t hQueue, [[maybe_unused]] const void *pMem,
     [[maybe_unused]] size_t size,
-    [[maybe_unused]] ur_usm_migration_flags_t flags,
+    ur_usm_migration_flags_t flags,
     uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
     ur_event_handle_t *phEvent) {
 
-  // return mapCLErrorToUR(clEnqueueMarkerWithWaitList(
-  //     cl_adapter::cast<cl_command_queue>(hQueue), numEventsInWaitList,
-  //     cl_adapter::cast<const cl_event *>(phEventWaitList),
-  //     cl_adapter::cast<cl_event *>(phEvent)));
-
-
   // Have to look up the context from the kernel
   cl_context CLContext;
   cl_int CLErr =
-  clGetCommandQueueInfo(cl_adapter::cast<cl_command_queue>(hQueue),
-                                       CL_QUEUE_CONTEXT, sizeof(cl_context),
-                                       &CLContext, nullptr);
+    clGetCommandQueueInfo(cl_adapter::cast<cl_command_queue>(hQueue),
+                          CL_QUEUE_CONTEXT, sizeof(cl_context), &CLContext,
+                          nullptr);
   if (CLErr != CL_SUCCESS) {
     return mapCLErrorToUR(CLErr);
   }
@@ -514,20 +508,22 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
       CLContext, cl_ext::ExtFuncPtrCache->clEnqueueMigrateMemINTELCache,
       cl_ext::EnqueueMigrateMemName, &FuncPtr)) {
     // Exit gracefully if unable to find USM function
-    cl_adapter::setErrorMessage("Prefetch hint ignored as current OpenCL version does not support clEnqueueMigrateMemINTEL", UR_RESULT_SUCCESS);
+    cl_adapter::setErrorMessage("Prefetch hint ignored as current OpenCL versio"
+                                "n does not support clEnqueueMigrateMemINTEL",
+                                UR_RESULT_SUCCESS);
     return UR_RESULT_SUCCESS;
   }
-      // cl_ext::getExtFuncFromContext<clHostMemAllocINTEL_fn>(
-      // CLContext, cl_ext::ExtFuncPtrCache->clHostMemAllocINTELCache,
-      // cl_ext::HostMemAllocName, &HostMemAlloc)
 
   cl_mem_migration_flags MigrationFlag;
-  if (flags == UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE) {
-    MigrationFlag = CL_MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED;
-  } else if (flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) {
-    MigrationFlag = CL_MIGRATE_MEM_OBJECT_HOST;
-  } else {
-    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+  switch (flags) {
+    case UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE:
+      MigrationFlag = CL_MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED;
+      break;
+    case UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST:
+      MigrationFlag = CL_MIGRATE_MEM_OBJECT_HOST;
+      break;
+    default:
+      return UR_RESULT_ERROR_INVALID_ENUMERATION;
   }
 
   return mapCLErrorToUR(
diff --git a/test/conformance/enqueue/urEnqueueUSMPrefetch.cpp b/test/conformance/enqueue/urEnqueueUSMPrefetch.cpp
index d0d6d507fd..603ca8c57d 100644
--- a/test/conformance/enqueue/urEnqueueUSMPrefetch.cpp
+++ b/test/conformance/enqueue/urEnqueueUSMPrefetch.cpp
@@ -131,3 +131,9 @@ TEST_P(urEnqueueUSMPrefetchTest, InvalidEventWaitList) {
 
     ASSERT_SUCCESS(urEventRelease(validEvent));
 }
+
+TEST_P(urEnqueueUSMPrefetchTest, InvalidMigrationFlag) {
+    ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION,
+                     urEnqueueUSMPrefetch(queue, ptr, allocation_size, 23, 0,
+                                          nullptr, nullptr));
+}
\ No newline at end of file

From 2143085f88c9a6746bde14ef827a36b13981da9d Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li@intel.com>
Date: Tue, 10 Dec 2024 11:38:49 -0800
Subject: [PATCH 14/20] Add handling for unsupported prefetch combinations

---
 source/adapters/level_zero/memory.cpp |  5 ++++-
 source/adapters/opencl/usm.cpp        | 22 +++++++++++++++++-----
 2 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/source/adapters/level_zero/memory.cpp b/source/adapters/level_zero/memory.cpp
index 5283ea4da3..00ae2c65c6 100644
--- a/source/adapters/level_zero/memory.cpp
+++ b/source/adapters/level_zero/memory.cpp
@@ -1239,7 +1239,6 @@ ur_result_t urEnqueueUSMPrefetch(
         *OutEvent ///< [in,out][optional] return an event object that identifies
                   ///< this particular command instance.
 ) {
-  std::ignore = Flags;
   // Lock automatically releases when this goes out of scope.
   std::scoped_lock<ur_shared_mutex> lock(Queue->Mutex);
 
@@ -1254,6 +1253,10 @@ ur_result_t urEnqueueUSMPrefetch(
   _ur_ze_event_list_t TmpWaitList;
   UR_CALL(TmpWaitList.createAndRetainUrZeEventList(
       NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine));
+  
+  // L0 does not suppot migrating from device to host yet: skip procedure
+  if (Flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST)
+    return UR_RESULT_SUCCESS;
 
   // Get a new command list to be used on this call
   ur_command_list_ptr_t CommandList{};
diff --git a/source/adapters/opencl/usm.cpp b/source/adapters/opencl/usm.cpp
index 66f694cb82..ec4b108f2f 100644
--- a/source/adapters/opencl/usm.cpp
+++ b/source/adapters/opencl/usm.cpp
@@ -526,11 +526,23 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
       return UR_RESULT_ERROR_INVALID_ENUMERATION;
   }
 
-  return mapCLErrorToUR(
-      FuncPtr(cl_adapter::cast<cl_command_queue>(hQueue), pMem, size,
-              MigrationFlag, numEventsInWaitList,
-              reinterpret_cast<const cl_event *>(phEventWaitList),
-              reinterpret_cast<cl_event *>(phEvent)));
+  cl_int Result =
+   FuncPtr(cl_adapter::cast<cl_command_queue>(hQueue), pMem, size,
+           MigrationFlag, numEventsInWaitList,
+           reinterpret_cast<const cl_event *>(phEventWaitList),
+           reinterpret_cast<cl_event *>(phEvent));
+
+  switch (Result) {
+    case CL_INVALID_VALUE:
+      cl_adapter::setErrorMessage("Prefetch hint ignored as current OpenCL "
+                                  "version does not support prefetching "
+                                  "(clEnqueueMigrateMemINTEL) from current "
+                                  "device to host (CL_MIGRATE_MEM_OBJECT_HOST)",
+                                  UR_RESULT_SUCCESS);
+      return UR_RESULT_SUCCESS;
+    default:
+      return mapCLErrorToUR(Result);
+  }
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMAdvise(

From 6a9b4e52f5661e86aa6948e742ded8fcff0798d9 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li@intel.com>
Date: Wed, 11 Dec 2024 11:35:51 -0800
Subject: [PATCH 15/20] Added warning messages and cleaned up code

---
 source/adapters/cuda/enqueue.cpp              | 17 ++++++++-------
 source/adapters/hip/enqueue.cpp               | 21 +++++++++++--------
 source/adapters/level_zero/command_buffer.cpp |  6 +++++-
 source/adapters/level_zero/memory.cpp         | 10 +++++----
 .../v2/queue_immediate_in_order.cpp           |  5 ++++-
 source/adapters/opencl/usm.cpp                |  1 +
 6 files changed, 38 insertions(+), 22 deletions(-)

diff --git a/source/adapters/cuda/enqueue.cpp b/source/adapters/cuda/enqueue.cpp
index 3998f2f7c1..b7effc24ea 100644
--- a/source/adapters/cuda/enqueue.cpp
+++ b/source/adapters/cuda/enqueue.cpp
@@ -1628,13 +1628,16 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
     const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent) {
   ur_device_handle_t Device = hQueue->getDevice();
   CUdevice TargetDevice;
-  if (flags == UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE) {
-    TargetDevice = Device->get();
-  } else if (flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) {
-    TargetDevice = CU_DEVICE_CPU;
-  } else {
-    setErrorMessage("Invalid USM migration flag", UR_RESULT_ERROR_INVALID_ENUMERATION);
-    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+  switch (flags) {
+    case UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE:
+      TargetDevice = Device->get();
+      break;
+    case UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST:
+      TargetDevice = CU_DEVICE_CPU;
+      break;
+    default:
+      setErrorMessage("Invalid USM migration flag", UR_RESULT_ERROR_INVALID_ENUMERATION);
+      return UR_RESULT_ERROR_INVALID_ENUMERATION;
   }
 
   size_t PointerRangeSize = 0;
diff --git a/source/adapters/hip/enqueue.cpp b/source/adapters/hip/enqueue.cpp
index ec568d606f..d90b0335ea 100644
--- a/source/adapters/hip/enqueue.cpp
+++ b/source/adapters/hip/enqueue.cpp
@@ -1369,15 +1369,18 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
   void *HIPDevicePtr = const_cast<void *>(pMem);
   ur_device_handle_t Device = hQueue->getDevice();
   hipDevice_t TargetDevice;
-  if (flags == UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE) {
-    TargetDevice = Device->get();
-  } else if (flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) {
-    // HIP doesn't have a constant for host like CUDA does; -1 is used instead
-    // https://github.com/ROCm/HIP/blob/3d60bd3a6415c2/docs/how-to/unified_memory.rst#L376
-    TargetDevice = -1;
-  } else {
-    setErrorMessage("Invalid USM migration flag", UR_RESULT_ERROR_INVALID_ENUMERATION);
-    return UR_RESULT_ERROR_INVALID_ENUMERATION;
+  switch (flags) {
+    case UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE:
+      TargetDevice = Device->get();
+      break;
+    case UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST:
+      // HIP doesn't have a constant for host like CUDA does; -1 is used instead
+      // https://github.com/ROCm/HIP/blob/3d60bd3a6415c2/docs/how-to/unified_memory.rst#L376
+      TargetDevice = -1;
+      break;
+    default:
+      cl_adapter::setErrorMessage("Invalid USM migration flag", UR_RESULT_ERROR_INVALID_ENUMERATION);
+      return UR_RESULT_ERROR_INVALID_ENUMERATION;
   }
 
 // HIP_POINTER_ATTRIBUTE_RANGE_SIZE is not an attribute in ROCM < 5,
diff --git a/source/adapters/level_zero/command_buffer.cpp b/source/adapters/level_zero/command_buffer.cpp
index 5ae19092a6..c3a5cb68b5 100644
--- a/source/adapters/level_zero/command_buffer.cpp
+++ b/source/adapters/level_zero/command_buffer.cpp
@@ -1290,7 +1290,11 @@ ur_result_t urCommandBufferAppendUSMPrefetchExp(
   std::ignore = EventWaitList;
   std::ignore = Event;
   std::ignore = Command;
-  std::ignore = Flags;
+
+  if (Flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) {
+    logger::warning("USM migration from device to host is not currently supported by level zero.");
+    return UR_RESULT_SUCCESS;
+  }
 
   if (CommandBuffer->IsInOrderCmdList) {
     // Add the prefetch command to the command buffer.
diff --git a/source/adapters/level_zero/memory.cpp b/source/adapters/level_zero/memory.cpp
index 00ae2c65c6..2eb0055fee 100644
--- a/source/adapters/level_zero/memory.cpp
+++ b/source/adapters/level_zero/memory.cpp
@@ -1239,6 +1239,12 @@ ur_result_t urEnqueueUSMPrefetch(
         *OutEvent ///< [in,out][optional] return an event object that identifies
                   ///< this particular command instance.
 ) {
+  // L0 does not suppot migrating from device to host yet: skip procedure
+  if (Flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) {
+    logger::warning("urEnqueueUSMPrefetch: Prefetch from device to host not yet supported by level zero");
+    return UR_RESULT_SUCCESS;
+  }
+
   // Lock automatically releases when this goes out of scope.
   std::scoped_lock<ur_shared_mutex> lock(Queue->Mutex);
 
@@ -1254,10 +1260,6 @@ ur_result_t urEnqueueUSMPrefetch(
   UR_CALL(TmpWaitList.createAndRetainUrZeEventList(
       NumEventsInWaitList, EventWaitList, Queue, UseCopyEngine));
   
-  // L0 does not suppot migrating from device to host yet: skip procedure
-  if (Flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST)
-    return UR_RESULT_SUCCESS;
-
   // Get a new command list to be used on this call
   ur_command_list_ptr_t CommandList{};
   // TODO: Change UseCopyEngine argument to 'true' once L0 backend
diff --git a/source/adapters/level_zero/v2/queue_immediate_in_order.cpp b/source/adapters/level_zero/v2/queue_immediate_in_order.cpp
index 05e48c8740..12e7046319 100644
--- a/source/adapters/level_zero/v2/queue_immediate_in_order.cpp
+++ b/source/adapters/level_zero/v2/queue_immediate_in_order.cpp
@@ -746,7 +746,10 @@ ur_result_t ur_queue_immediate_in_order_t::enqueueUSMPrefetch(
     ur_event_handle_t *phEvent) {
   TRACK_SCOPE_LATENCY("ur_queue_immediate_in_order_t::enqueueUSMPrefetch");
 
-  std::ignore = flags;
+  if (flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) {
+    setErrorMessage("Prefetch from device to host not yet supported by level zero.", UR_RESULT_SUCCESS);
+    return UR_RESULT_SUCCESS;
+  }
 
   std::scoped_lock<ur_shared_mutex> lock(this->Mutex);
 
diff --git a/source/adapters/opencl/usm.cpp b/source/adapters/opencl/usm.cpp
index ec4b108f2f..b343aeba24 100644
--- a/source/adapters/opencl/usm.cpp
+++ b/source/adapters/opencl/usm.cpp
@@ -523,6 +523,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
       MigrationFlag = CL_MIGRATE_MEM_OBJECT_HOST;
       break;
     default:
+      cl_adapter::setErrorMessage("Invalid USM migration flag", UR_RESULT_ERROR_INVALID_ENUMERATION);
       return UR_RESULT_ERROR_INVALID_ENUMERATION;
   }
 

From 869a089ad75815e3cc924a7a6985f810a412012f Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li@intel.com>
Date: Wed, 11 Dec 2024 11:40:25 -0800
Subject: [PATCH 16/20] enforce column width

---
 source/adapters/cuda/enqueue.cpp                           | 3 ++-
 source/adapters/hip/enqueue.cpp                            | 3 ++-
 source/adapters/level_zero/command_buffer.cpp              | 3 ++-
 source/adapters/level_zero/memory.cpp                      | 3 ++-
 source/adapters/level_zero/v2/queue_immediate_in_order.cpp | 3 ++-
 source/adapters/opencl/usm.cpp                             | 3 ++-
 6 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/source/adapters/cuda/enqueue.cpp b/source/adapters/cuda/enqueue.cpp
index b7effc24ea..8b21cd99cf 100644
--- a/source/adapters/cuda/enqueue.cpp
+++ b/source/adapters/cuda/enqueue.cpp
@@ -1636,7 +1636,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
       TargetDevice = CU_DEVICE_CPU;
       break;
     default:
-      setErrorMessage("Invalid USM migration flag", UR_RESULT_ERROR_INVALID_ENUMERATION);
+      setErrorMessage("Invalid USM migration flag",
+                      UR_RESULT_ERROR_INVALID_ENUMERATION);
       return UR_RESULT_ERROR_INVALID_ENUMERATION;
   }
 
diff --git a/source/adapters/hip/enqueue.cpp b/source/adapters/hip/enqueue.cpp
index d90b0335ea..e75829fb67 100644
--- a/source/adapters/hip/enqueue.cpp
+++ b/source/adapters/hip/enqueue.cpp
@@ -1379,7 +1379,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
       TargetDevice = -1;
       break;
     default:
-      cl_adapter::setErrorMessage("Invalid USM migration flag", UR_RESULT_ERROR_INVALID_ENUMERATION);
+      cl_adapter::setErrorMessage("Invalid USM migration flag", 
+                                  UR_RESULT_ERROR_INVALID_ENUMERATION);
       return UR_RESULT_ERROR_INVALID_ENUMERATION;
   }
 
diff --git a/source/adapters/level_zero/command_buffer.cpp b/source/adapters/level_zero/command_buffer.cpp
index c3a5cb68b5..54a657890d 100644
--- a/source/adapters/level_zero/command_buffer.cpp
+++ b/source/adapters/level_zero/command_buffer.cpp
@@ -1292,7 +1292,8 @@ ur_result_t urCommandBufferAppendUSMPrefetchExp(
   std::ignore = Command;
 
   if (Flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) {
-    logger::warning("USM migration from device to host is not currently supported by level zero.");
+    logger::warning("USM migration from device to host is not currently "
+                    "supported by level zero.");
     return UR_RESULT_SUCCESS;
   }
 
diff --git a/source/adapters/level_zero/memory.cpp b/source/adapters/level_zero/memory.cpp
index 2eb0055fee..4009647be3 100644
--- a/source/adapters/level_zero/memory.cpp
+++ b/source/adapters/level_zero/memory.cpp
@@ -1241,7 +1241,8 @@ ur_result_t urEnqueueUSMPrefetch(
 ) {
   // L0 does not suppot migrating from device to host yet: skip procedure
   if (Flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) {
-    logger::warning("urEnqueueUSMPrefetch: Prefetch from device to host not yet supported by level zero");
+    logger::warning("urEnqueueUSMPrefetch: Prefetch from device to host not yet"
+                    " supported by level zero");
     return UR_RESULT_SUCCESS;
   }
 
diff --git a/source/adapters/level_zero/v2/queue_immediate_in_order.cpp b/source/adapters/level_zero/v2/queue_immediate_in_order.cpp
index 12e7046319..cd6036c437 100644
--- a/source/adapters/level_zero/v2/queue_immediate_in_order.cpp
+++ b/source/adapters/level_zero/v2/queue_immediate_in_order.cpp
@@ -747,7 +747,8 @@ ur_result_t ur_queue_immediate_in_order_t::enqueueUSMPrefetch(
   TRACK_SCOPE_LATENCY("ur_queue_immediate_in_order_t::enqueueUSMPrefetch");
 
   if (flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) {
-    setErrorMessage("Prefetch from device to host not yet supported by level zero.", UR_RESULT_SUCCESS);
+    setErrorMessage("Prefetch from device to host not yet supported by level "
+                    "zero.", UR_RESULT_SUCCESS);
     return UR_RESULT_SUCCESS;
   }
 
diff --git a/source/adapters/opencl/usm.cpp b/source/adapters/opencl/usm.cpp
index b343aeba24..88dc5a9c2c 100644
--- a/source/adapters/opencl/usm.cpp
+++ b/source/adapters/opencl/usm.cpp
@@ -523,7 +523,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
       MigrationFlag = CL_MIGRATE_MEM_OBJECT_HOST;
       break;
     default:
-      cl_adapter::setErrorMessage("Invalid USM migration flag", UR_RESULT_ERROR_INVALID_ENUMERATION);
+      cl_adapter::setErrorMessage("Invalid USM migration flag",
+                                  UR_RESULT_ERROR_INVALID_ENUMERATION);
       return UR_RESULT_ERROR_INVALID_ENUMERATION;
   }
 

From 491cf056ebe39b3fb0dafa310535b666eedc4081 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li@intel.com>
Date: Wed, 11 Dec 2024 15:44:02 -0800
Subject: [PATCH 17/20] Fixed bug in hip

---
 source/adapters/hip/enqueue.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/adapters/hip/enqueue.cpp b/source/adapters/hip/enqueue.cpp
index e75829fb67..c19416cb28 100644
--- a/source/adapters/hip/enqueue.cpp
+++ b/source/adapters/hip/enqueue.cpp
@@ -1379,7 +1379,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urEnqueueUSMPrefetch(
       TargetDevice = -1;
       break;
     default:
-      cl_adapter::setErrorMessage("Invalid USM migration flag", 
+      setErrorMessage("Invalid USM migration flag", 
                                   UR_RESULT_ERROR_INVALID_ENUMERATION);
       return UR_RESULT_ERROR_INVALID_ENUMERATION;
   }

From ff19760f39914bf50e4df8f0264c008a20b42be9 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li@intel.com>
Date: Fri, 20 Dec 2024 08:30:08 -0800
Subject: [PATCH 18/20] Update testing for command buffer

---
 test/conformance/exp_command_buffer/commands.cpp         | 9 +++++++--
 .../conformance/exp_command_buffer/update/event_sync.cpp | 5 +++--
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/test/conformance/exp_command_buffer/commands.cpp b/test/conformance/exp_command_buffer/commands.cpp
index 5c4d4e7e4d..17ee08d668 100644
--- a/test/conformance/exp_command_buffer/commands.cpp
+++ b/test/conformance/exp_command_buffer/commands.cpp
@@ -124,8 +124,13 @@ TEST_P(urCommandBufferCommandsTest, urCommandBufferAppendMemBufferFillExp) {
 
 TEST_P(urCommandBufferCommandsTest, urCommandBufferAppendUSMPrefetchExp) {
     ASSERT_SUCCESS(urCommandBufferAppendUSMPrefetchExp(
-        cmd_buf_handle, device_ptrs[0], allocation_size, 0, 0, nullptr, 0,
-        nullptr, nullptr, nullptr, nullptr));
+        cmd_buf_handle, device_ptrs[0], allocation_size,
+        UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE, 0, nullptr, 0, nullptr, nullptr,
+        nullptr, nullptr));
+    ASSERT_SUCCESS(urCommandBufferAppendUSMPrefetchExp(
+        cmd_buf_handle, device_ptrs[0], allocation_size,
+        UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST, 0, nullptr, 0, nullptr, nullptr,
+        nullptr, nullptr));
 }
 
 TEST_P(urCommandBufferCommandsTest, urCommandBufferAppendUSMAdviseExp) {
diff --git a/test/conformance/exp_command_buffer/update/event_sync.cpp b/test/conformance/exp_command_buffer/update/event_sync.cpp
index 13e1bed968..d2f4aa03f5 100644
--- a/test/conformance/exp_command_buffer/update/event_sync.cpp
+++ b/test/conformance/exp_command_buffer/update/event_sync.cpp
@@ -598,8 +598,9 @@ TEST_P(CommandEventSyncUpdateTest, USMPrefetchExp) {
     // Test prefetch command waiting on queue event
     ASSERT_SUCCESS(urCommandBufferAppendUSMPrefetchExp(
         updatable_cmd_buf_handle, device_ptrs[1], allocation_size,
-        0 /* migration flags*/, 0, nullptr, 1, &external_events[0], nullptr,
-        &external_events[1], &command_handles[0]));
+        UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE, 0, nullptr, 1,
+        &external_events[0], nullptr, &external_events[1],
+        &command_handles[0]));
     ASSERT_NE(nullptr, command_handles[0]);
     ASSERT_SUCCESS(urCommandBufferFinalizeExp(updatable_cmd_buf_handle));
     ASSERT_SUCCESS(urCommandBufferEnqueueExp(updatable_cmd_buf_handle, queue, 0,

From 17c485e89bd1f2c2ba32f3213f79e346ec141808 Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li@intel.com>
Date: Mon, 6 Jan 2025 10:18:35 -0800
Subject: [PATCH 19/20] Fix issue with command dependencies

---
 source/adapters/level_zero/command_buffer.cpp | 34 +++++++++++--------
 1 file changed, 20 insertions(+), 14 deletions(-)

diff --git a/source/adapters/level_zero/command_buffer.cpp b/source/adapters/level_zero/command_buffer.cpp
index b76550ad0d..03efcf8994 100644
--- a/source/adapters/level_zero/command_buffer.cpp
+++ b/source/adapters/level_zero/command_buffer.cpp
@@ -1301,17 +1301,17 @@ ur_result_t urCommandBufferAppendUSMPrefetchExp(
   std::ignore = Event;
   std::ignore = Command;
 
-  if (Flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) {
-    logger::warning("USM migration from device to host is not currently "
-                    "supported by level zero.");
-    return UR_RESULT_SUCCESS;
-  }
-
   if (CommandBuffer->IsInOrderCmdList) {
-    // Add the prefetch command to the command buffer.
-    // Note that L0 does not handle migration flags.
-    ZE2UR_CALL(zeCommandListAppendMemoryPrefetch,
-               (CommandBuffer->ZeComputeCommandList, Mem, Size));
+    if (Flags == UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE) {
+      // Add the prefetch command to the command buffer.
+      ZE2UR_CALL(zeCommandListAppendMemoryPrefetch,
+                (CommandBuffer->ZeComputeCommandList, Mem, Size));
+    } else {
+      // L0 currently does not handle migration flags -- All other migration
+      // behavior is ignored:
+      logger::warning("USM migration from device to host is not currently "
+                      "supported by level zero.");
+    }
   } else {
     std::vector<ze_event_handle_t> ZeEventList;
     ze_event_handle_t ZeLaunchEvent = nullptr;
@@ -1325,10 +1325,16 @@ ur_result_t urCommandBufferAppendUSMPrefetchExp(
                   ZeEventList.data()));
     }
 
-    // Add the prefetch command to the command buffer.
-    // Note that L0 does not handle migration flags.
-    ZE2UR_CALL(zeCommandListAppendMemoryPrefetch,
-               (CommandBuffer->ZeComputeCommandList, Mem, Size));
+    if (Flags == UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE) {
+      // Add the prefetch command to the command buffer.
+      ZE2UR_CALL(zeCommandListAppendMemoryPrefetch,
+                (CommandBuffer->ZeComputeCommandList, Mem, Size));
+    } else {
+      // L0 currently does not handle migration flags -- All other migration
+      // behavior is ignored:
+      logger::warning("USM migration from device to host is not currently "
+                      "supported by level zero.");
+    }
 
     // Level Zero does not have a completion "event" with the prefetch API,
     // so manually add command to signal our event.

From dd11f8580d5afae0b36f5a354d7734c3f3ab88da Mon Sep 17 00:00:00 2001
From: "Li, Ian" <ian.li@intel.com>
Date: Tue, 7 Jan 2025 13:06:21 -0800
Subject: [PATCH 20/20] Fix issue with disregarding event dependencies

---
 source/adapters/level_zero/memory.cpp          | 17 ++++++++---------
 .../level_zero/v2/queue_immediate_in_order.cpp | 18 +++++++++---------
 2 files changed, 17 insertions(+), 18 deletions(-)

diff --git a/source/adapters/level_zero/memory.cpp b/source/adapters/level_zero/memory.cpp
index 4009647be3..ce174d9243 100644
--- a/source/adapters/level_zero/memory.cpp
+++ b/source/adapters/level_zero/memory.cpp
@@ -1239,13 +1239,6 @@ ur_result_t urEnqueueUSMPrefetch(
         *OutEvent ///< [in,out][optional] return an event object that identifies
                   ///< this particular command instance.
 ) {
-  // L0 does not suppot migrating from device to host yet: skip procedure
-  if (Flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) {
-    logger::warning("urEnqueueUSMPrefetch: Prefetch from device to host not yet"
-                    " supported by level zero");
-    return UR_RESULT_SUCCESS;
-  }
-
   // Lock automatically releases when this goes out of scope.
   std::scoped_lock<ur_shared_mutex> lock(Queue->Mutex);
 
@@ -1285,8 +1278,14 @@ ur_result_t urEnqueueUSMPrefetch(
     ZE2UR_CALL(zeCommandListAppendWaitOnEvents,
                (ZeCommandList, WaitList.Length, WaitList.ZeEventList));
   }
-  // TODO: figure out how to translate "flags"
-  ZE2UR_CALL(zeCommandListAppendMemoryPrefetch, (ZeCommandList, Mem, Size));
+
+  if (Flags == UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE) {
+    ZE2UR_CALL(zeCommandListAppendMemoryPrefetch, (ZeCommandList, Mem, Size));
+  } else {
+    // L0 does not suppot migrating from device to host yet: skip procedure
+    logger::warning("urEnqueueUSMPrefetch: Prefetch from device to host not yet"
+                    " supported by level zero");
+  }
 
   // TODO: Level Zero does not have a completion "event" with the prefetch API,
   // so manually add command to signal our event.
diff --git a/source/adapters/level_zero/v2/queue_immediate_in_order.cpp b/source/adapters/level_zero/v2/queue_immediate_in_order.cpp
index 28e2b5e35f..8d6afb2a23 100644
--- a/source/adapters/level_zero/v2/queue_immediate_in_order.cpp
+++ b/source/adapters/level_zero/v2/queue_immediate_in_order.cpp
@@ -779,12 +779,6 @@ ur_result_t ur_queue_immediate_in_order_t::enqueueUSMPrefetch(
     ur_event_handle_t *phEvent) {
   TRACK_SCOPE_LATENCY("ur_queue_immediate_in_order_t::enqueueUSMPrefetch");
 
-  if (flags == UR_USM_MIGRATION_FLAG_DEVICE_TO_HOST) {
-    setErrorMessage("Prefetch from device to host not yet supported by level "
-                    "zero.", UR_RESULT_SUCCESS);
-    return UR_RESULT_SUCCESS;
-  }
-
   std::scoped_lock<ur_shared_mutex> lock(this->Mutex);
 
   auto signalEvent = getSignalEvent(phEvent, UR_COMMAND_USM_PREFETCH);
@@ -796,9 +790,15 @@ ur_result_t ur_queue_immediate_in_order_t::enqueueUSMPrefetch(
     ZE2UR_CALL(zeCommandListAppendWaitOnEvents,
                (handler.commandList.get(), numWaitEvents, pWaitEvents));
   }
-  // TODO: figure out how to translate "flags"
-  ZE2UR_CALL(zeCommandListAppendMemoryPrefetch,
-             (handler.commandList.get(), pMem, size));
+
+  if (flags == UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE) {
+    ZE2UR_CALL(zeCommandListAppendMemoryPrefetch,
+               (handler.commandList.get(), pMem, size));
+  } else {
+    // L0 does not suppot migrating from device to host yet: skip procedure
+    setErrorMessage("Prefetch from device to host not yet supported by level "
+                    "zero.", UR_RESULT_SUCCESS);
+  }
 
   if (signalEvent) {
     ZE2UR_CALL(zeCommandListAppendSignalEvent,