• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2015-2021 The Khronos Group Inc.
2 //
3 // SPDX-License-Identifier: Apache-2.0 OR MIT
4 //
5 
6 // This header is generated from the Khronos Vulkan XML API Registry.
7 
8 #ifndef VULKAN_HANDLES_HPP
9 #define VULKAN_HANDLES_HPP
10 
11 namespace VULKAN_HPP_NAMESPACE
12 {
13   struct AabbPositionsKHR;
14   using AabbPositionsNV = AabbPositionsKHR;
15   struct AccelerationStructureBuildGeometryInfoKHR;
16   struct AccelerationStructureBuildRangeInfoKHR;
17   struct AccelerationStructureBuildSizesInfoKHR;
18   struct AccelerationStructureCreateInfoKHR;
19   struct AccelerationStructureCreateInfoNV;
20   struct AccelerationStructureDeviceAddressInfoKHR;
21   struct AccelerationStructureGeometryAabbsDataKHR;
22   union AccelerationStructureGeometryDataKHR;
23   struct AccelerationStructureGeometryInstancesDataKHR;
24   struct AccelerationStructureGeometryKHR;
25   struct AccelerationStructureGeometryMotionTrianglesDataNV;
26   struct AccelerationStructureGeometryTrianglesDataKHR;
27   struct AccelerationStructureInfoNV;
28   struct AccelerationStructureInstanceKHR;
29   using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;
30   struct AccelerationStructureMatrixMotionInstanceNV;
31   struct AccelerationStructureMemoryRequirementsInfoNV;
32   struct AccelerationStructureMotionInfoNV;
33   union AccelerationStructureMotionInstanceDataNV;
34   struct AccelerationStructureMotionInstanceNV;
35   struct AccelerationStructureSRTMotionInstanceNV;
36   struct AccelerationStructureVersionInfoKHR;
37   struct AcquireNextImageInfoKHR;
38   struct AcquireProfilingLockInfoKHR;
39   struct AllocationCallbacks;
40 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
41   struct AndroidHardwareBufferFormatPropertiesANDROID;
42 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
43 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
44   struct AndroidHardwareBufferPropertiesANDROID;
45 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
46 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
47   struct AndroidHardwareBufferUsageANDROID;
48 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
49 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
50   struct AndroidSurfaceCreateInfoKHR;
51 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
52   struct ApplicationInfo;
53   struct AttachmentDescription;
54   struct AttachmentDescription2;
55   using AttachmentDescription2KHR = AttachmentDescription2;
56   struct AttachmentDescriptionStencilLayout;
57   using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;
58   struct AttachmentReference;
59   struct AttachmentReference2;
60   using AttachmentReference2KHR = AttachmentReference2;
61   struct AttachmentReferenceStencilLayout;
62   using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;
63   struct AttachmentSampleLocationsEXT;
64   struct BaseInStructure;
65   struct BaseOutStructure;
66   struct BindAccelerationStructureMemoryInfoNV;
67   struct BindBufferMemoryDeviceGroupInfo;
68   using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo;
69   struct BindBufferMemoryInfo;
70   using BindBufferMemoryInfoKHR = BindBufferMemoryInfo;
71   struct BindImageMemoryDeviceGroupInfo;
72   using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo;
73   struct BindImageMemoryInfo;
74   using BindImageMemoryInfoKHR = BindImageMemoryInfo;
75   struct BindImageMemorySwapchainInfoKHR;
76   struct BindImagePlaneMemoryInfo;
77   using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo;
78   struct BindIndexBufferIndirectCommandNV;
79   struct BindShaderGroupIndirectCommandNV;
80   struct BindSparseInfo;
81   struct BindVertexBufferIndirectCommandNV;
82   struct BlitImageInfo2KHR;
83   struct BufferCopy;
84   struct BufferCopy2KHR;
85   struct BufferCreateInfo;
86   struct BufferDeviceAddressCreateInfoEXT;
87   struct BufferDeviceAddressInfo;
88   using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo;
89   using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo;
90   struct BufferImageCopy;
91   struct BufferImageCopy2KHR;
92   struct BufferMemoryBarrier;
93   struct BufferMemoryBarrier2KHR;
94   struct BufferMemoryRequirementsInfo2;
95   using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;
96   struct BufferOpaqueCaptureAddressCreateInfo;
97   using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo;
98   struct BufferViewCreateInfo;
99   struct CalibratedTimestampInfoEXT;
100   struct CheckpointData2NV;
101   struct CheckpointDataNV;
102   struct ClearAttachment;
103   union ClearColorValue;
104   struct ClearDepthStencilValue;
105   struct ClearRect;
106   union ClearValue;
107   struct CoarseSampleLocationNV;
108   struct CoarseSampleOrderCustomNV;
109   struct CommandBufferAllocateInfo;
110   struct CommandBufferBeginInfo;
111   struct CommandBufferInheritanceConditionalRenderingInfoEXT;
112   struct CommandBufferInheritanceInfo;
113   struct CommandBufferInheritanceRenderPassTransformInfoQCOM;
114   struct CommandBufferInheritanceViewportScissorInfoNV;
115   struct CommandBufferSubmitInfoKHR;
116   struct CommandPoolCreateInfo;
117   struct ComponentMapping;
118   struct ComputePipelineCreateInfo;
119   struct ConditionalRenderingBeginInfoEXT;
120   struct ConformanceVersion;
121   using ConformanceVersionKHR = ConformanceVersion;
122   struct CooperativeMatrixPropertiesNV;
123   struct CopyAccelerationStructureInfoKHR;
124   struct CopyAccelerationStructureToMemoryInfoKHR;
125   struct CopyBufferInfo2KHR;
126   struct CopyBufferToImageInfo2KHR;
127   struct CopyCommandTransformInfoQCOM;
128   struct CopyDescriptorSet;
129   struct CopyImageInfo2KHR;
130   struct CopyImageToBufferInfo2KHR;
131   struct CopyMemoryToAccelerationStructureInfoKHR;
132   struct CuFunctionCreateInfoNVX;
133   struct CuLaunchInfoNVX;
134   struct CuModuleCreateInfoNVX;
135 #if defined( VK_USE_PLATFORM_WIN32_KHR )
136   struct D3D12FenceSubmitInfoKHR;
137 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
138   struct DebugMarkerMarkerInfoEXT;
139   struct DebugMarkerObjectNameInfoEXT;
140   struct DebugMarkerObjectTagInfoEXT;
141   struct DebugReportCallbackCreateInfoEXT;
142   struct DebugUtilsLabelEXT;
143   struct DebugUtilsMessengerCallbackDataEXT;
144   struct DebugUtilsMessengerCreateInfoEXT;
145   struct DebugUtilsObjectNameInfoEXT;
146   struct DebugUtilsObjectTagInfoEXT;
147   struct DedicatedAllocationBufferCreateInfoNV;
148   struct DedicatedAllocationImageCreateInfoNV;
149   struct DedicatedAllocationMemoryAllocateInfoNV;
150   struct DependencyInfoKHR;
151   struct DescriptorBufferInfo;
152   struct DescriptorImageInfo;
153   struct DescriptorPoolCreateInfo;
154   struct DescriptorPoolInlineUniformBlockCreateInfoEXT;
155   struct DescriptorPoolSize;
156   struct DescriptorSetAllocateInfo;
157   struct DescriptorSetLayoutBinding;
158   struct DescriptorSetLayoutBindingFlagsCreateInfo;
159   using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;
160   struct DescriptorSetLayoutCreateInfo;
161   struct DescriptorSetLayoutSupport;
162   using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;
163   struct DescriptorSetVariableDescriptorCountAllocateInfo;
164   using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo;
165   struct DescriptorSetVariableDescriptorCountLayoutSupport;
166   using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport;
167   struct DescriptorUpdateTemplateCreateInfo;
168   using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo;
169   struct DescriptorUpdateTemplateEntry;
170   using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry;
171   struct DeviceCreateInfo;
172   struct DeviceDeviceMemoryReportCreateInfoEXT;
173   struct DeviceDiagnosticsConfigCreateInfoNV;
174   struct DeviceEventInfoEXT;
175   struct DeviceGroupBindSparseInfo;
176   using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo;
177   struct DeviceGroupCommandBufferBeginInfo;
178   using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo;
179   struct DeviceGroupDeviceCreateInfo;
180   using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo;
181   struct DeviceGroupPresentCapabilitiesKHR;
182   struct DeviceGroupPresentInfoKHR;
183   struct DeviceGroupRenderPassBeginInfo;
184   using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo;
185   struct DeviceGroupSubmitInfo;
186   using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo;
187   struct DeviceGroupSwapchainCreateInfoKHR;
188   struct DeviceMemoryOpaqueCaptureAddressInfo;
189   using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;
190   struct DeviceMemoryOverallocationCreateInfoAMD;
191   struct DeviceMemoryReportCallbackDataEXT;
192   union DeviceOrHostAddressConstKHR;
193   union DeviceOrHostAddressKHR;
194   struct DevicePrivateDataCreateInfoEXT;
195   struct DeviceQueueCreateInfo;
196   struct DeviceQueueGlobalPriorityCreateInfoEXT;
197   struct DeviceQueueInfo2;
198 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
199   struct DirectFBSurfaceCreateInfoEXT;
200 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
201   struct DispatchIndirectCommand;
202   struct DisplayEventInfoEXT;
203   struct DisplayModeCreateInfoKHR;
204   struct DisplayModeParametersKHR;
205   struct DisplayModeProperties2KHR;
206   struct DisplayModePropertiesKHR;
207   struct DisplayNativeHdrSurfaceCapabilitiesAMD;
208   struct DisplayPlaneCapabilities2KHR;
209   struct DisplayPlaneCapabilitiesKHR;
210   struct DisplayPlaneInfo2KHR;
211   struct DisplayPlaneProperties2KHR;
212   struct DisplayPlanePropertiesKHR;
213   struct DisplayPowerInfoEXT;
214   struct DisplayPresentInfoKHR;
215   struct DisplayProperties2KHR;
216   struct DisplayPropertiesKHR;
217   struct DisplaySurfaceCreateInfoKHR;
218   struct DrawIndexedIndirectCommand;
219   struct DrawIndirectCommand;
220   struct DrawMeshTasksIndirectCommandNV;
221   struct DrmFormatModifierPropertiesEXT;
222   struct DrmFormatModifierPropertiesListEXT;
223   struct EventCreateInfo;
224   struct ExportFenceCreateInfo;
225   using ExportFenceCreateInfoKHR = ExportFenceCreateInfo;
226 #if defined( VK_USE_PLATFORM_WIN32_KHR )
227   struct ExportFenceWin32HandleInfoKHR;
228 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
229   struct ExportMemoryAllocateInfo;
230   using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo;
231   struct ExportMemoryAllocateInfoNV;
232 #if defined( VK_USE_PLATFORM_WIN32_KHR )
233   struct ExportMemoryWin32HandleInfoKHR;
234 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
235 #if defined( VK_USE_PLATFORM_WIN32_KHR )
236   struct ExportMemoryWin32HandleInfoNV;
237 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
238   struct ExportSemaphoreCreateInfo;
239   using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo;
240 #if defined( VK_USE_PLATFORM_WIN32_KHR )
241   struct ExportSemaphoreWin32HandleInfoKHR;
242 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
243   struct ExtensionProperties;
244   struct Extent2D;
245   struct Extent3D;
246   struct ExternalBufferProperties;
247   using ExternalBufferPropertiesKHR = ExternalBufferProperties;
248   struct ExternalFenceProperties;
249   using ExternalFencePropertiesKHR = ExternalFenceProperties;
250 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
251   struct ExternalFormatANDROID;
252 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
253   struct ExternalImageFormatProperties;
254   using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties;
255   struct ExternalImageFormatPropertiesNV;
256   struct ExternalMemoryBufferCreateInfo;
257   using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo;
258   struct ExternalMemoryImageCreateInfo;
259   using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo;
260   struct ExternalMemoryImageCreateInfoNV;
261   struct ExternalMemoryProperties;
262   using ExternalMemoryPropertiesKHR = ExternalMemoryProperties;
263   struct ExternalSemaphoreProperties;
264   using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties;
265   struct FenceCreateInfo;
266   struct FenceGetFdInfoKHR;
267 #if defined( VK_USE_PLATFORM_WIN32_KHR )
268   struct FenceGetWin32HandleInfoKHR;
269 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
270   struct FilterCubicImageViewImageFormatPropertiesEXT;
271   struct FormatProperties;
272   struct FormatProperties2;
273   using FormatProperties2KHR = FormatProperties2;
274   struct FragmentShadingRateAttachmentInfoKHR;
275   struct FramebufferAttachmentImageInfo;
276   using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;
277   struct FramebufferAttachmentsCreateInfo;
278   using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;
279   struct FramebufferCreateInfo;
280   struct FramebufferMixedSamplesCombinationNV;
281   struct GeneratedCommandsInfoNV;
282   struct GeneratedCommandsMemoryRequirementsInfoNV;
283   struct GeometryAABBNV;
284   struct GeometryDataNV;
285   struct GeometryNV;
286   struct GeometryTrianglesNV;
287   struct GraphicsPipelineCreateInfo;
288   struct GraphicsPipelineShaderGroupsCreateInfoNV;
289   struct GraphicsShaderGroupCreateInfoNV;
290   struct HdrMetadataEXT;
291   struct HeadlessSurfaceCreateInfoEXT;
292 #if defined( VK_USE_PLATFORM_IOS_MVK )
293   struct IOSSurfaceCreateInfoMVK;
294 #endif /*VK_USE_PLATFORM_IOS_MVK*/
295   struct ImageBlit;
296   struct ImageBlit2KHR;
297   struct ImageCopy;
298   struct ImageCopy2KHR;
299   struct ImageCreateInfo;
300   struct ImageDrmFormatModifierExplicitCreateInfoEXT;
301   struct ImageDrmFormatModifierListCreateInfoEXT;
302   struct ImageDrmFormatModifierPropertiesEXT;
303   struct ImageFormatListCreateInfo;
304   using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;
305   struct ImageFormatProperties;
306   struct ImageFormatProperties2;
307   using ImageFormatProperties2KHR = ImageFormatProperties2;
308   struct ImageMemoryBarrier;
309   struct ImageMemoryBarrier2KHR;
310   struct ImageMemoryRequirementsInfo2;
311   using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;
312 #if defined( VK_USE_PLATFORM_FUCHSIA )
313   struct ImagePipeSurfaceCreateInfoFUCHSIA;
314 #endif /*VK_USE_PLATFORM_FUCHSIA*/
315   struct ImagePlaneMemoryRequirementsInfo;
316   using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo;
317   struct ImageResolve;
318   struct ImageResolve2KHR;
319   struct ImageSparseMemoryRequirementsInfo2;
320   using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;
321   struct ImageStencilUsageCreateInfo;
322   using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;
323   struct ImageSubresource;
324   struct ImageSubresourceLayers;
325   struct ImageSubresourceRange;
326   struct ImageSwapchainCreateInfoKHR;
327   struct ImageViewASTCDecodeModeEXT;
328   struct ImageViewAddressPropertiesNVX;
329   struct ImageViewCreateInfo;
330   struct ImageViewHandleInfoNVX;
331   struct ImageViewUsageCreateInfo;
332   using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo;
333 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
334   struct ImportAndroidHardwareBufferInfoANDROID;
335 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
336   struct ImportFenceFdInfoKHR;
337 #if defined( VK_USE_PLATFORM_WIN32_KHR )
338   struct ImportFenceWin32HandleInfoKHR;
339 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
340   struct ImportMemoryFdInfoKHR;
341   struct ImportMemoryHostPointerInfoEXT;
342 #if defined( VK_USE_PLATFORM_WIN32_KHR )
343   struct ImportMemoryWin32HandleInfoKHR;
344 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
345 #if defined( VK_USE_PLATFORM_WIN32_KHR )
346   struct ImportMemoryWin32HandleInfoNV;
347 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
348 #if defined( VK_USE_PLATFORM_FUCHSIA )
349   struct ImportMemoryZirconHandleInfoFUCHSIA;
350 #endif /*VK_USE_PLATFORM_FUCHSIA*/
351   struct ImportSemaphoreFdInfoKHR;
352 #if defined( VK_USE_PLATFORM_WIN32_KHR )
353   struct ImportSemaphoreWin32HandleInfoKHR;
354 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
355 #if defined( VK_USE_PLATFORM_FUCHSIA )
356   struct ImportSemaphoreZirconHandleInfoFUCHSIA;
357 #endif /*VK_USE_PLATFORM_FUCHSIA*/
358   struct IndirectCommandsLayoutCreateInfoNV;
359   struct IndirectCommandsLayoutTokenNV;
360   struct IndirectCommandsStreamNV;
361   struct InitializePerformanceApiInfoINTEL;
362   struct InputAttachmentAspectReference;
363   using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference;
364   struct InstanceCreateInfo;
365   struct LayerProperties;
366 #if defined( VK_USE_PLATFORM_MACOS_MVK )
367   struct MacOSSurfaceCreateInfoMVK;
368 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
369   struct MappedMemoryRange;
370   struct MemoryAllocateFlagsInfo;
371   using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo;
372   struct MemoryAllocateInfo;
373   struct MemoryBarrier;
374   struct MemoryBarrier2KHR;
375   struct MemoryDedicatedAllocateInfo;
376   using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo;
377   struct MemoryDedicatedRequirements;
378   using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements;
379   struct MemoryFdPropertiesKHR;
380 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
381   struct MemoryGetAndroidHardwareBufferInfoANDROID;
382 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
383   struct MemoryGetFdInfoKHR;
384   struct MemoryGetRemoteAddressInfoNV;
385 #if defined( VK_USE_PLATFORM_WIN32_KHR )
386   struct MemoryGetWin32HandleInfoKHR;
387 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
388 #if defined( VK_USE_PLATFORM_FUCHSIA )
389   struct MemoryGetZirconHandleInfoFUCHSIA;
390 #endif /*VK_USE_PLATFORM_FUCHSIA*/
391   struct MemoryHeap;
392   struct MemoryHostPointerPropertiesEXT;
393   struct MemoryOpaqueCaptureAddressAllocateInfo;
394   using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;
395   struct MemoryPriorityAllocateInfoEXT;
396   struct MemoryRequirements;
397   struct MemoryRequirements2;
398   using MemoryRequirements2KHR = MemoryRequirements2;
399   struct MemoryType;
400 #if defined( VK_USE_PLATFORM_WIN32_KHR )
401   struct MemoryWin32HandlePropertiesKHR;
402 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
403 #if defined( VK_USE_PLATFORM_FUCHSIA )
404   struct MemoryZirconHandlePropertiesFUCHSIA;
405 #endif /*VK_USE_PLATFORM_FUCHSIA*/
406 #if defined( VK_USE_PLATFORM_METAL_EXT )
407   struct MetalSurfaceCreateInfoEXT;
408 #endif /*VK_USE_PLATFORM_METAL_EXT*/
409   struct MultiDrawIndexedInfoEXT;
410   struct MultiDrawInfoEXT;
411   struct MultisamplePropertiesEXT;
412   struct MutableDescriptorTypeCreateInfoVALVE;
413   struct MutableDescriptorTypeListVALVE;
414   struct Offset2D;
415   struct Offset3D;
416   struct PastPresentationTimingGOOGLE;
417   struct PerformanceConfigurationAcquireInfoINTEL;
418   struct PerformanceCounterDescriptionKHR;
419   struct PerformanceCounterKHR;
420   union PerformanceCounterResultKHR;
421   struct PerformanceMarkerInfoINTEL;
422   struct PerformanceOverrideInfoINTEL;
423   struct PerformanceQuerySubmitInfoKHR;
424   struct PerformanceStreamMarkerInfoINTEL;
425   union PerformanceValueDataINTEL;
426   struct PerformanceValueINTEL;
427   struct PhysicalDevice16BitStorageFeatures;
428   using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures;
429   struct PhysicalDevice4444FormatsFeaturesEXT;
430   struct PhysicalDevice8BitStorageFeatures;
431   using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures;
432   struct PhysicalDeviceASTCDecodeFeaturesEXT;
433   struct PhysicalDeviceAccelerationStructureFeaturesKHR;
434   struct PhysicalDeviceAccelerationStructurePropertiesKHR;
435   struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
436   struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT;
437   struct PhysicalDeviceBufferDeviceAddressFeatures;
438   using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures;
439   struct PhysicalDeviceBufferDeviceAddressFeaturesEXT;
440   using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT;
441   struct PhysicalDeviceCoherentMemoryFeaturesAMD;
442   struct PhysicalDeviceColorWriteEnableFeaturesEXT;
443   struct PhysicalDeviceComputeShaderDerivativesFeaturesNV;
444   struct PhysicalDeviceConditionalRenderingFeaturesEXT;
445   struct PhysicalDeviceConservativeRasterizationPropertiesEXT;
446   struct PhysicalDeviceCooperativeMatrixFeaturesNV;
447   struct PhysicalDeviceCooperativeMatrixPropertiesNV;
448   struct PhysicalDeviceCornerSampledImageFeaturesNV;
449   struct PhysicalDeviceCoverageReductionModeFeaturesNV;
450   struct PhysicalDeviceCustomBorderColorFeaturesEXT;
451   struct PhysicalDeviceCustomBorderColorPropertiesEXT;
452   struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
453   struct PhysicalDeviceDepthClipEnableFeaturesEXT;
454   struct PhysicalDeviceDepthStencilResolveProperties;
455   using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties;
456   struct PhysicalDeviceDescriptorIndexingFeatures;
457   using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;
458   struct PhysicalDeviceDescriptorIndexingProperties;
459   using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;
460   struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
461   struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV;
462   struct PhysicalDeviceDeviceMemoryReportFeaturesEXT;
463   struct PhysicalDeviceDiagnosticsConfigFeaturesNV;
464   struct PhysicalDeviceDiscardRectanglePropertiesEXT;
465   struct PhysicalDeviceDriverProperties;
466   using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties;
467   struct PhysicalDeviceDrmPropertiesEXT;
468   struct PhysicalDeviceExclusiveScissorFeaturesNV;
469   struct PhysicalDeviceExtendedDynamicState2FeaturesEXT;
470   struct PhysicalDeviceExtendedDynamicStateFeaturesEXT;
471   struct PhysicalDeviceExternalBufferInfo;
472   using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo;
473   struct PhysicalDeviceExternalFenceInfo;
474   using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo;
475   struct PhysicalDeviceExternalImageFormatInfo;
476   using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo;
477   struct PhysicalDeviceExternalMemoryHostPropertiesEXT;
478   struct PhysicalDeviceExternalMemoryRDMAFeaturesNV;
479   struct PhysicalDeviceExternalSemaphoreInfo;
480   using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo;
481   struct PhysicalDeviceFeatures;
482   struct PhysicalDeviceFeatures2;
483   using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
484   struct PhysicalDeviceFloatControlsProperties;
485   using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;
486   struct PhysicalDeviceFragmentDensityMap2FeaturesEXT;
487   struct PhysicalDeviceFragmentDensityMap2PropertiesEXT;
488   struct PhysicalDeviceFragmentDensityMapFeaturesEXT;
489   struct PhysicalDeviceFragmentDensityMapPropertiesEXT;
490   struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV;
491   struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
492   struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV;
493   struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV;
494   struct PhysicalDeviceFragmentShadingRateFeaturesKHR;
495   struct PhysicalDeviceFragmentShadingRateKHR;
496   struct PhysicalDeviceFragmentShadingRatePropertiesKHR;
497   struct PhysicalDeviceGlobalPriorityQueryFeaturesEXT;
498   struct PhysicalDeviceGroupProperties;
499   using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties;
500   struct PhysicalDeviceHostQueryResetFeatures;
501   using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;
502   struct PhysicalDeviceIDProperties;
503   using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties;
504   struct PhysicalDeviceImageDrmFormatModifierInfoEXT;
505   struct PhysicalDeviceImageFormatInfo2;
506   using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2;
507   struct PhysicalDeviceImageRobustnessFeaturesEXT;
508   struct PhysicalDeviceImageViewImageFormatInfoEXT;
509   struct PhysicalDeviceImagelessFramebufferFeatures;
510   using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures;
511   struct PhysicalDeviceIndexTypeUint8FeaturesEXT;
512   struct PhysicalDeviceInheritedViewportScissorFeaturesNV;
513   struct PhysicalDeviceInlineUniformBlockFeaturesEXT;
514   struct PhysicalDeviceInlineUniformBlockPropertiesEXT;
515   struct PhysicalDeviceLimits;
516   struct PhysicalDeviceLineRasterizationFeaturesEXT;
517   struct PhysicalDeviceLineRasterizationPropertiesEXT;
518   struct PhysicalDeviceMaintenance3Properties;
519   using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
520   struct PhysicalDeviceMemoryBudgetPropertiesEXT;
521   struct PhysicalDeviceMemoryPriorityFeaturesEXT;
522   struct PhysicalDeviceMemoryProperties;
523   struct PhysicalDeviceMemoryProperties2;
524   using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2;
525   struct PhysicalDeviceMeshShaderFeaturesNV;
526   struct PhysicalDeviceMeshShaderPropertiesNV;
527   struct PhysicalDeviceMultiDrawFeaturesEXT;
528   struct PhysicalDeviceMultiDrawPropertiesEXT;
529   struct PhysicalDeviceMultiviewFeatures;
530   using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures;
531   struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
532   struct PhysicalDeviceMultiviewProperties;
533   using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties;
534   struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
535   struct PhysicalDevicePCIBusInfoPropertiesEXT;
536   struct PhysicalDevicePerformanceQueryFeaturesKHR;
537   struct PhysicalDevicePerformanceQueryPropertiesKHR;
538   struct PhysicalDevicePipelineCreationCacheControlFeaturesEXT;
539   struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
540   struct PhysicalDevicePointClippingProperties;
541   using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
542 #if defined( VK_ENABLE_BETA_EXTENSIONS )
543   struct PhysicalDevicePortabilitySubsetFeaturesKHR;
544 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
545 #if defined( VK_ENABLE_BETA_EXTENSIONS )
546   struct PhysicalDevicePortabilitySubsetPropertiesKHR;
547 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
548   struct PhysicalDevicePrivateDataFeaturesEXT;
549   struct PhysicalDeviceProperties;
550   struct PhysicalDeviceProperties2;
551   using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
552   struct PhysicalDeviceProtectedMemoryFeatures;
553   struct PhysicalDeviceProtectedMemoryProperties;
554   struct PhysicalDeviceProvokingVertexFeaturesEXT;
555   struct PhysicalDeviceProvokingVertexPropertiesEXT;
556   struct PhysicalDevicePushDescriptorPropertiesKHR;
557   struct PhysicalDeviceRayQueryFeaturesKHR;
558   struct PhysicalDeviceRayTracingMotionBlurFeaturesNV;
559   struct PhysicalDeviceRayTracingPipelineFeaturesKHR;
560   struct PhysicalDeviceRayTracingPipelinePropertiesKHR;
561   struct PhysicalDeviceRayTracingPropertiesNV;
562   struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
563   struct PhysicalDeviceRobustness2FeaturesEXT;
564   struct PhysicalDeviceRobustness2PropertiesEXT;
565   struct PhysicalDeviceSampleLocationsPropertiesEXT;
566   struct PhysicalDeviceSamplerFilterMinmaxProperties;
567   using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties;
568   struct PhysicalDeviceSamplerYcbcrConversionFeatures;
569   using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures;
570   struct PhysicalDeviceScalarBlockLayoutFeatures;
571   using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;
572   struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
573   using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
574   struct PhysicalDeviceShaderAtomicFloatFeaturesEXT;
575   struct PhysicalDeviceShaderAtomicInt64Features;
576   using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features;
577   struct PhysicalDeviceShaderClockFeaturesKHR;
578   struct PhysicalDeviceShaderCoreProperties2AMD;
579   struct PhysicalDeviceShaderCorePropertiesAMD;
580   struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
581   struct PhysicalDeviceShaderDrawParametersFeatures;
582   using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;
583   struct PhysicalDeviceShaderFloat16Int8Features;
584   using PhysicalDeviceFloat16Int8FeaturesKHR       = PhysicalDeviceShaderFloat16Int8Features;
585   using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
586   struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT;
587   struct PhysicalDeviceShaderImageFootprintFeaturesNV;
588   struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
589   struct PhysicalDeviceShaderSMBuiltinsFeaturesNV;
590   struct PhysicalDeviceShaderSMBuiltinsPropertiesNV;
591   struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
592   using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
593   struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
594   struct PhysicalDeviceShaderTerminateInvocationFeaturesKHR;
595   struct PhysicalDeviceShadingRateImageFeaturesNV;
596   struct PhysicalDeviceShadingRateImagePropertiesNV;
597   struct PhysicalDeviceSparseImageFormatInfo2;
598   using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2;
599   struct PhysicalDeviceSparseProperties;
600   struct PhysicalDeviceSubgroupProperties;
601   struct PhysicalDeviceSubgroupSizeControlFeaturesEXT;
602   struct PhysicalDeviceSubgroupSizeControlPropertiesEXT;
603   struct PhysicalDeviceSubpassShadingFeaturesHUAWEI;
604   struct PhysicalDeviceSubpassShadingPropertiesHUAWEI;
605   struct PhysicalDeviceSurfaceInfo2KHR;
606   struct PhysicalDeviceSynchronization2FeaturesKHR;
607   struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
608   struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT;
609   struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
610   struct PhysicalDeviceTimelineSemaphoreFeatures;
611   using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures;
612   struct PhysicalDeviceTimelineSemaphoreProperties;
613   using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties;
614   struct PhysicalDeviceToolPropertiesEXT;
615   struct PhysicalDeviceTransformFeedbackFeaturesEXT;
616   struct PhysicalDeviceTransformFeedbackPropertiesEXT;
617   struct PhysicalDeviceUniformBufferStandardLayoutFeatures;
618   using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures;
619   struct PhysicalDeviceVariablePointersFeatures;
620   using PhysicalDeviceVariablePointerFeatures     = PhysicalDeviceVariablePointersFeatures;
621   using PhysicalDeviceVariablePointerFeaturesKHR  = PhysicalDeviceVariablePointersFeatures;
622   using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures;
623   struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
624   struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT;
625   struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT;
626 #if defined( VK_ENABLE_BETA_EXTENSIONS )
627   struct PhysicalDeviceVideoFormatInfoKHR;
628 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
629   struct PhysicalDeviceVulkan11Features;
630   struct PhysicalDeviceVulkan11Properties;
631   struct PhysicalDeviceVulkan12Features;
632   struct PhysicalDeviceVulkan12Properties;
633   struct PhysicalDeviceVulkanMemoryModelFeatures;
634   using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures;
635   struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
636   struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
637   struct PhysicalDeviceYcbcrImageArraysFeaturesEXT;
638   struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
639   struct PipelineCacheCreateInfo;
640   struct PipelineCacheHeaderVersionOne;
641   struct PipelineColorBlendAdvancedStateCreateInfoEXT;
642   struct PipelineColorBlendAttachmentState;
643   struct PipelineColorBlendStateCreateInfo;
644   struct PipelineColorWriteCreateInfoEXT;
645   struct PipelineCompilerControlCreateInfoAMD;
646   struct PipelineCoverageModulationStateCreateInfoNV;
647   struct PipelineCoverageReductionStateCreateInfoNV;
648   struct PipelineCoverageToColorStateCreateInfoNV;
649   struct PipelineCreationFeedbackCreateInfoEXT;
650   struct PipelineCreationFeedbackEXT;
651   struct PipelineDepthStencilStateCreateInfo;
652   struct PipelineDiscardRectangleStateCreateInfoEXT;
653   struct PipelineDynamicStateCreateInfo;
654   struct PipelineExecutableInfoKHR;
655   struct PipelineExecutableInternalRepresentationKHR;
656   struct PipelineExecutablePropertiesKHR;
657   struct PipelineExecutableStatisticKHR;
658   union PipelineExecutableStatisticValueKHR;
659   struct PipelineFragmentShadingRateEnumStateCreateInfoNV;
660   struct PipelineFragmentShadingRateStateCreateInfoKHR;
661   struct PipelineInfoKHR;
662   struct PipelineInputAssemblyStateCreateInfo;
663   struct PipelineLayoutCreateInfo;
664   struct PipelineLibraryCreateInfoKHR;
665   struct PipelineMultisampleStateCreateInfo;
666   struct PipelineRasterizationConservativeStateCreateInfoEXT;
667   struct PipelineRasterizationDepthClipStateCreateInfoEXT;
668   struct PipelineRasterizationLineStateCreateInfoEXT;
669   struct PipelineRasterizationProvokingVertexStateCreateInfoEXT;
670   struct PipelineRasterizationStateCreateInfo;
671   struct PipelineRasterizationStateRasterizationOrderAMD;
672   struct PipelineRasterizationStateStreamCreateInfoEXT;
673   struct PipelineRepresentativeFragmentTestStateCreateInfoNV;
674   struct PipelineSampleLocationsStateCreateInfoEXT;
675   struct PipelineShaderStageCreateInfo;
676   struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
677   struct PipelineTessellationDomainOriginStateCreateInfo;
678   using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo;
679   struct PipelineTessellationStateCreateInfo;
680   struct PipelineVertexInputDivisorStateCreateInfoEXT;
681   struct PipelineVertexInputStateCreateInfo;
682   struct PipelineViewportCoarseSampleOrderStateCreateInfoNV;
683   struct PipelineViewportExclusiveScissorStateCreateInfoNV;
684   struct PipelineViewportShadingRateImageStateCreateInfoNV;
685   struct PipelineViewportStateCreateInfo;
686   struct PipelineViewportSwizzleStateCreateInfoNV;
687   struct PipelineViewportWScalingStateCreateInfoNV;
688 #if defined( VK_USE_PLATFORM_GGP )
689   struct PresentFrameTokenGGP;
690 #endif /*VK_USE_PLATFORM_GGP*/
691   struct PresentInfoKHR;
692   struct PresentRegionKHR;
693   struct PresentRegionsKHR;
694   struct PresentTimeGOOGLE;
695   struct PresentTimesInfoGOOGLE;
696   struct PrivateDataSlotCreateInfoEXT;
697   struct ProtectedSubmitInfo;
698   struct PushConstantRange;
699   struct QueryPoolCreateInfo;
700   struct QueryPoolPerformanceCreateInfoKHR;
701   struct QueryPoolPerformanceQueryCreateInfoINTEL;
702   using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;
703   struct QueueFamilyCheckpointProperties2NV;
704   struct QueueFamilyCheckpointPropertiesNV;
705   struct QueueFamilyGlobalPriorityPropertiesEXT;
706   struct QueueFamilyProperties;
707   struct QueueFamilyProperties2;
708   using QueueFamilyProperties2KHR = QueueFamilyProperties2;
709   struct RayTracingPipelineCreateInfoKHR;
710   struct RayTracingPipelineCreateInfoNV;
711   struct RayTracingPipelineInterfaceCreateInfoKHR;
712   struct RayTracingShaderGroupCreateInfoKHR;
713   struct RayTracingShaderGroupCreateInfoNV;
714   struct Rect2D;
715   struct RectLayerKHR;
716   struct RefreshCycleDurationGOOGLE;
717   struct RenderPassAttachmentBeginInfo;
718   using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;
719   struct RenderPassBeginInfo;
720   struct RenderPassCreateInfo;
721   struct RenderPassCreateInfo2;
722   using RenderPassCreateInfo2KHR = RenderPassCreateInfo2;
723   struct RenderPassFragmentDensityMapCreateInfoEXT;
724   struct RenderPassInputAttachmentAspectCreateInfo;
725   using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo;
726   struct RenderPassMultiviewCreateInfo;
727   using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo;
728   struct RenderPassSampleLocationsBeginInfoEXT;
729   struct RenderPassTransformBeginInfoQCOM;
730   struct ResolveImageInfo2KHR;
731   struct SRTDataNV;
732   struct SampleLocationEXT;
733   struct SampleLocationsInfoEXT;
734   struct SamplerCreateInfo;
735   struct SamplerCustomBorderColorCreateInfoEXT;
736   struct SamplerReductionModeCreateInfo;
737   using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;
738   struct SamplerYcbcrConversionCreateInfo;
739   using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo;
740   struct SamplerYcbcrConversionImageFormatProperties;
741   using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties;
742   struct SamplerYcbcrConversionInfo;
743   using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo;
744 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
745   struct ScreenSurfaceCreateInfoQNX;
746 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
747   struct SemaphoreCreateInfo;
748   struct SemaphoreGetFdInfoKHR;
749 #if defined( VK_USE_PLATFORM_WIN32_KHR )
750   struct SemaphoreGetWin32HandleInfoKHR;
751 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
752 #if defined( VK_USE_PLATFORM_FUCHSIA )
753   struct SemaphoreGetZirconHandleInfoFUCHSIA;
754 #endif /*VK_USE_PLATFORM_FUCHSIA*/
755   struct SemaphoreSignalInfo;
756   using SemaphoreSignalInfoKHR = SemaphoreSignalInfo;
757   struct SemaphoreSubmitInfoKHR;
758   struct SemaphoreTypeCreateInfo;
759   using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo;
760   struct SemaphoreWaitInfo;
761   using SemaphoreWaitInfoKHR = SemaphoreWaitInfo;
762   struct SetStateFlagsIndirectCommandNV;
763   struct ShaderModuleCreateInfo;
764   struct ShaderModuleValidationCacheCreateInfoEXT;
765   struct ShaderResourceUsageAMD;
766   struct ShaderStatisticsInfoAMD;
767   struct ShadingRatePaletteNV;
768   struct SharedPresentSurfaceCapabilitiesKHR;
769   struct SparseBufferMemoryBindInfo;
770   struct SparseImageFormatProperties;
771   struct SparseImageFormatProperties2;
772   using SparseImageFormatProperties2KHR = SparseImageFormatProperties2;
773   struct SparseImageMemoryBind;
774   struct SparseImageMemoryBindInfo;
775   struct SparseImageMemoryRequirements;
776   struct SparseImageMemoryRequirements2;
777   using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
778   struct SparseImageOpaqueMemoryBindInfo;
779   struct SparseMemoryBind;
780   struct SpecializationInfo;
781   struct SpecializationMapEntry;
782   struct StencilOpState;
783 #if defined( VK_USE_PLATFORM_GGP )
784   struct StreamDescriptorSurfaceCreateInfoGGP;
785 #endif /*VK_USE_PLATFORM_GGP*/
786   struct StridedDeviceAddressRegionKHR;
787   struct SubmitInfo;
788   struct SubmitInfo2KHR;
789   struct SubpassBeginInfo;
790   using SubpassBeginInfoKHR = SubpassBeginInfo;
791   struct SubpassDependency;
792   struct SubpassDependency2;
793   using SubpassDependency2KHR = SubpassDependency2;
794   struct SubpassDescription;
795   struct SubpassDescription2;
796   using SubpassDescription2KHR = SubpassDescription2;
797   struct SubpassDescriptionDepthStencilResolve;
798   using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;
799   struct SubpassEndInfo;
800   using SubpassEndInfoKHR = SubpassEndInfo;
801   struct SubpassSampleLocationsEXT;
802   struct SubpassShadingPipelineCreateInfoHUAWEI;
803   struct SubresourceLayout;
804   struct SurfaceCapabilities2EXT;
805   struct SurfaceCapabilities2KHR;
806 #if defined( VK_USE_PLATFORM_WIN32_KHR )
807   struct SurfaceCapabilitiesFullScreenExclusiveEXT;
808 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
809   struct SurfaceCapabilitiesKHR;
810   struct SurfaceFormat2KHR;
811   struct SurfaceFormatKHR;
812 #if defined( VK_USE_PLATFORM_WIN32_KHR )
813   struct SurfaceFullScreenExclusiveInfoEXT;
814 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
815 #if defined( VK_USE_PLATFORM_WIN32_KHR )
816   struct SurfaceFullScreenExclusiveWin32InfoEXT;
817 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
818   struct SurfaceProtectedCapabilitiesKHR;
819   struct SwapchainCounterCreateInfoEXT;
820   struct SwapchainCreateInfoKHR;
821   struct SwapchainDisplayNativeHdrCreateInfoAMD;
822   struct TextureLODGatherFormatPropertiesAMD;
823   struct TimelineSemaphoreSubmitInfo;
824   using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo;
825   struct TraceRaysIndirectCommandKHR;
826   struct TransformMatrixKHR;
827   using TransformMatrixNV = TransformMatrixKHR;
828   struct ValidationCacheCreateInfoEXT;
829   struct ValidationFeaturesEXT;
830   struct ValidationFlagsEXT;
831   struct VertexInputAttributeDescription;
832   struct VertexInputAttributeDescription2EXT;
833   struct VertexInputBindingDescription;
834   struct VertexInputBindingDescription2EXT;
835   struct VertexInputBindingDivisorDescriptionEXT;
836 #if defined( VK_USE_PLATFORM_VI_NN )
837   struct ViSurfaceCreateInfoNN;
838 #endif /*VK_USE_PLATFORM_VI_NN*/
839 #if defined( VK_ENABLE_BETA_EXTENSIONS )
840   struct VideoBeginCodingInfoKHR;
841 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
842 #if defined( VK_ENABLE_BETA_EXTENSIONS )
843   struct VideoBindMemoryKHR;
844 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
845 #if defined( VK_ENABLE_BETA_EXTENSIONS )
846   struct VideoCapabilitiesKHR;
847 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
848 #if defined( VK_ENABLE_BETA_EXTENSIONS )
849   struct VideoCodingControlInfoKHR;
850 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
851 #if defined( VK_ENABLE_BETA_EXTENSIONS )
852   struct VideoDecodeH264CapabilitiesEXT;
853 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
854 #if defined( VK_ENABLE_BETA_EXTENSIONS )
855   struct VideoDecodeH264DpbSlotInfoEXT;
856 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
857 #if defined( VK_ENABLE_BETA_EXTENSIONS )
858   struct VideoDecodeH264MvcEXT;
859 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
860 #if defined( VK_ENABLE_BETA_EXTENSIONS )
861   struct VideoDecodeH264PictureInfoEXT;
862 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
863 #if defined( VK_ENABLE_BETA_EXTENSIONS )
864   struct VideoDecodeH264ProfileEXT;
865 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
866 #if defined( VK_ENABLE_BETA_EXTENSIONS )
867   struct VideoDecodeH264SessionCreateInfoEXT;
868 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
869 #if defined( VK_ENABLE_BETA_EXTENSIONS )
870   struct VideoDecodeH264SessionParametersAddInfoEXT;
871 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
872 #if defined( VK_ENABLE_BETA_EXTENSIONS )
873   struct VideoDecodeH264SessionParametersCreateInfoEXT;
874 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
875 #if defined( VK_ENABLE_BETA_EXTENSIONS )
876   struct VideoDecodeH265CapabilitiesEXT;
877 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
878 #if defined( VK_ENABLE_BETA_EXTENSIONS )
879   struct VideoDecodeH265DpbSlotInfoEXT;
880 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
881 #if defined( VK_ENABLE_BETA_EXTENSIONS )
882   struct VideoDecodeH265PictureInfoEXT;
883 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
884 #if defined( VK_ENABLE_BETA_EXTENSIONS )
885   struct VideoDecodeH265ProfileEXT;
886 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
887 #if defined( VK_ENABLE_BETA_EXTENSIONS )
888   struct VideoDecodeH265SessionCreateInfoEXT;
889 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
890 #if defined( VK_ENABLE_BETA_EXTENSIONS )
891   struct VideoDecodeH265SessionParametersAddInfoEXT;
892 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
893 #if defined( VK_ENABLE_BETA_EXTENSIONS )
894   struct VideoDecodeH265SessionParametersCreateInfoEXT;
895 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
896 #if defined( VK_ENABLE_BETA_EXTENSIONS )
897   struct VideoDecodeInfoKHR;
898 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
899 #if defined( VK_ENABLE_BETA_EXTENSIONS )
900   struct VideoEncodeH264CapabilitiesEXT;
901 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
902 #if defined( VK_ENABLE_BETA_EXTENSIONS )
903   struct VideoEncodeH264DpbSlotInfoEXT;
904 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
905 #if defined( VK_ENABLE_BETA_EXTENSIONS )
906   struct VideoEncodeH264EmitPictureParametersEXT;
907 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
908 #if defined( VK_ENABLE_BETA_EXTENSIONS )
909   struct VideoEncodeH264NaluSliceEXT;
910 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
911 #if defined( VK_ENABLE_BETA_EXTENSIONS )
912   struct VideoEncodeH264ProfileEXT;
913 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
914 #if defined( VK_ENABLE_BETA_EXTENSIONS )
915   struct VideoEncodeH264SessionCreateInfoEXT;
916 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
917 #if defined( VK_ENABLE_BETA_EXTENSIONS )
918   struct VideoEncodeH264SessionParametersAddInfoEXT;
919 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
920 #if defined( VK_ENABLE_BETA_EXTENSIONS )
921   struct VideoEncodeH264SessionParametersCreateInfoEXT;
922 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
923 #if defined( VK_ENABLE_BETA_EXTENSIONS )
924   struct VideoEncodeH264VclFrameInfoEXT;
925 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
926 #if defined( VK_ENABLE_BETA_EXTENSIONS )
927   struct VideoEncodeInfoKHR;
928 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
929 #if defined( VK_ENABLE_BETA_EXTENSIONS )
930   struct VideoEncodeRateControlInfoKHR;
931 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
932 #if defined( VK_ENABLE_BETA_EXTENSIONS )
933   struct VideoEndCodingInfoKHR;
934 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
935 #if defined( VK_ENABLE_BETA_EXTENSIONS )
936   struct VideoFormatPropertiesKHR;
937 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
938 #if defined( VK_ENABLE_BETA_EXTENSIONS )
939   struct VideoGetMemoryPropertiesKHR;
940 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
941 #if defined( VK_ENABLE_BETA_EXTENSIONS )
942   struct VideoPictureResourceKHR;
943 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
944 #if defined( VK_ENABLE_BETA_EXTENSIONS )
945   struct VideoProfileKHR;
946 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
947 #if defined( VK_ENABLE_BETA_EXTENSIONS )
948   struct VideoProfilesKHR;
949 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
950 #if defined( VK_ENABLE_BETA_EXTENSIONS )
951   struct VideoQueueFamilyProperties2KHR;
952 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
953 #if defined( VK_ENABLE_BETA_EXTENSIONS )
954   struct VideoReferenceSlotKHR;
955 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
956 #if defined( VK_ENABLE_BETA_EXTENSIONS )
957   struct VideoSessionCreateInfoKHR;
958 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
959 #if defined( VK_ENABLE_BETA_EXTENSIONS )
960   struct VideoSessionParametersCreateInfoKHR;
961 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
962 #if defined( VK_ENABLE_BETA_EXTENSIONS )
963   struct VideoSessionParametersUpdateInfoKHR;
964 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
965   struct Viewport;
966   struct ViewportSwizzleNV;
967   struct ViewportWScalingNV;
968 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
969   struct WaylandSurfaceCreateInfoKHR;
970 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
971 #if defined( VK_USE_PLATFORM_WIN32_KHR )
972   struct Win32KeyedMutexAcquireReleaseInfoKHR;
973 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
974 #if defined( VK_USE_PLATFORM_WIN32_KHR )
975   struct Win32KeyedMutexAcquireReleaseInfoNV;
976 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
977 #if defined( VK_USE_PLATFORM_WIN32_KHR )
978   struct Win32SurfaceCreateInfoKHR;
979 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
980   struct WriteDescriptorSet;
981   struct WriteDescriptorSetAccelerationStructureKHR;
982   struct WriteDescriptorSetAccelerationStructureNV;
983   struct WriteDescriptorSetInlineUniformBlockEXT;
984   struct XYColorEXT;
985 #if defined( VK_USE_PLATFORM_XCB_KHR )
986   struct XcbSurfaceCreateInfoKHR;
987 #endif /*VK_USE_PLATFORM_XCB_KHR*/
988 #if defined( VK_USE_PLATFORM_XLIB_KHR )
989   struct XlibSurfaceCreateInfoKHR;
990 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
991 
992   class SurfaceKHR
993   {
994   public:
995     using CType = VkSurfaceKHR;
996 
997     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
998       VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR;
999     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1000       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR;
1001 
1002   public:
1003     VULKAN_HPP_CONSTEXPR         SurfaceKHR() = default;
SurfaceKHR(std::nullptr_t)1004     VULKAN_HPP_CONSTEXPR         SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
SurfaceKHR(VkSurfaceKHR surfaceKHR)1005     VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( surfaceKHR )
1006     {}
1007 
1008 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkSurfaceKHR surfaceKHR)1009     SurfaceKHR & operator=( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT
1010     {
1011       m_surfaceKHR = surfaceKHR;
1012       return *this;
1013     }
1014 #endif
1015 
operator =(std::nullptr_t)1016     SurfaceKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1017     {
1018       m_surfaceKHR = {};
1019       return *this;
1020     }
1021 
1022 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1023     auto operator<=>( SurfaceKHR const & ) const = default;
1024 #else
operator ==(SurfaceKHR const & rhs) const1025     bool operator==( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1026     {
1027       return m_surfaceKHR == rhs.m_surfaceKHR;
1028     }
1029 
operator !=(SurfaceKHR const & rhs) const1030     bool operator!=( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1031     {
1032       return m_surfaceKHR != rhs.m_surfaceKHR;
1033     }
1034 
operator <(SurfaceKHR const & rhs) const1035     bool operator<( SurfaceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1036     {
1037       return m_surfaceKHR < rhs.m_surfaceKHR;
1038     }
1039 #endif
1040 
operator VkSurfaceKHR() const1041     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const VULKAN_HPP_NOEXCEPT
1042     {
1043       return m_surfaceKHR;
1044     }
1045 
operator bool() const1046     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1047     {
1048       return m_surfaceKHR != VK_NULL_HANDLE;
1049     }
1050 
operator !() const1051     bool operator!() const VULKAN_HPP_NOEXCEPT
1052     {
1053       return m_surfaceKHR == VK_NULL_HANDLE;
1054     }
1055 
1056   private:
1057     VkSurfaceKHR m_surfaceKHR = {};
1058   };
1059   static_assert( sizeof( VULKAN_HPP_NAMESPACE::SurfaceKHR ) == sizeof( VkSurfaceKHR ),
1060                  "handle and wrapper have different size!" );
1061 
1062   template <>
1063   struct VULKAN_HPP_DEPRECATED(
1064     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSurfaceKHR>
1065   {
1066     using type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
1067   };
1068 
1069   template <>
1070   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR>
1071   {
1072     using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
1073   };
1074 
1075   template <>
1076   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
1077                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR>
1078   {
1079     using Type = VULKAN_HPP_NAMESPACE::SurfaceKHR;
1080   };
1081 
1082   template <>
1083   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SurfaceKHR>
1084   {
1085     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1086   };
1087 
1088   class DebugReportCallbackEXT
1089   {
1090   public:
1091     using CType = VkDebugReportCallbackEXT;
1092 
1093     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1094       VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT;
1095     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1096       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT;
1097 
1098   public:
1099     VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT() = default;
DebugReportCallbackEXT(std::nullptr_t)1100     VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
1101     VULKAN_HPP_TYPESAFE_EXPLICIT
DebugReportCallbackEXT(VkDebugReportCallbackEXT debugReportCallbackEXT)1102       DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
1103       : m_debugReportCallbackEXT( debugReportCallbackEXT )
1104     {}
1105 
1106 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDebugReportCallbackEXT debugReportCallbackEXT)1107     DebugReportCallbackEXT & operator=( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT
1108     {
1109       m_debugReportCallbackEXT = debugReportCallbackEXT;
1110       return *this;
1111     }
1112 #endif
1113 
operator =(std::nullptr_t)1114     DebugReportCallbackEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1115     {
1116       m_debugReportCallbackEXT = {};
1117       return *this;
1118     }
1119 
1120 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1121     auto operator<=>( DebugReportCallbackEXT const & ) const = default;
1122 #else
operator ==(DebugReportCallbackEXT const & rhs) const1123     bool operator==( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1124     {
1125       return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT;
1126     }
1127 
operator !=(DebugReportCallbackEXT const & rhs) const1128     bool operator!=( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1129     {
1130       return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT;
1131     }
1132 
operator <(DebugReportCallbackEXT const & rhs) const1133     bool operator<( DebugReportCallbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1134     {
1135       return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT;
1136     }
1137 #endif
1138 
operator VkDebugReportCallbackEXT() const1139     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT
1140     {
1141       return m_debugReportCallbackEXT;
1142     }
1143 
operator bool() const1144     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1145     {
1146       return m_debugReportCallbackEXT != VK_NULL_HANDLE;
1147     }
1148 
operator !() const1149     bool operator!() const VULKAN_HPP_NOEXCEPT
1150     {
1151       return m_debugReportCallbackEXT == VK_NULL_HANDLE;
1152     }
1153 
1154   private:
1155     VkDebugReportCallbackEXT m_debugReportCallbackEXT = {};
1156   };
1157   static_assert( sizeof( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ),
1158                  "handle and wrapper have different size!" );
1159 
1160   template <>
1161   struct VULKAN_HPP_DEPRECATED(
1162     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDebugReportCallbackEXT>
1163   {
1164     using type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
1165   };
1166 
1167   template <>
1168   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT>
1169   {
1170     using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
1171   };
1172 
1173   template <>
1174   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
1175                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT>
1176   {
1177     using Type = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT;
1178   };
1179 
1180   template <>
1181   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>
1182   {
1183     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1184   };
1185 
1186   class DebugUtilsMessengerEXT
1187   {
1188   public:
1189     using CType = VkDebugUtilsMessengerEXT;
1190 
1191     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1192       VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT;
1193     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1194       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
1195 
1196   public:
1197     VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT() = default;
DebugUtilsMessengerEXT(std::nullptr_t)1198     VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
1199     VULKAN_HPP_TYPESAFE_EXPLICIT
DebugUtilsMessengerEXT(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)1200       DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
1201       : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )
1202     {}
1203 
1204 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)1205     DebugUtilsMessengerEXT & operator=( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT
1206     {
1207       m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;
1208       return *this;
1209     }
1210 #endif
1211 
operator =(std::nullptr_t)1212     DebugUtilsMessengerEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1213     {
1214       m_debugUtilsMessengerEXT = {};
1215       return *this;
1216     }
1217 
1218 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1219     auto operator<=>( DebugUtilsMessengerEXT const & ) const = default;
1220 #else
operator ==(DebugUtilsMessengerEXT const & rhs) const1221     bool operator==( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1222     {
1223       return m_debugUtilsMessengerEXT == rhs.m_debugUtilsMessengerEXT;
1224     }
1225 
operator !=(DebugUtilsMessengerEXT const & rhs) const1226     bool operator!=( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1227     {
1228       return m_debugUtilsMessengerEXT != rhs.m_debugUtilsMessengerEXT;
1229     }
1230 
operator <(DebugUtilsMessengerEXT const & rhs) const1231     bool operator<( DebugUtilsMessengerEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
1232     {
1233       return m_debugUtilsMessengerEXT < rhs.m_debugUtilsMessengerEXT;
1234     }
1235 #endif
1236 
operator VkDebugUtilsMessengerEXT() const1237     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT
1238     {
1239       return m_debugUtilsMessengerEXT;
1240     }
1241 
operator bool() const1242     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1243     {
1244       return m_debugUtilsMessengerEXT != VK_NULL_HANDLE;
1245     }
1246 
operator !() const1247     bool operator!() const VULKAN_HPP_NOEXCEPT
1248     {
1249       return m_debugUtilsMessengerEXT == VK_NULL_HANDLE;
1250     }
1251 
1252   private:
1253     VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {};
1254   };
1255   static_assert( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ),
1256                  "handle and wrapper have different size!" );
1257 
1258   template <>
1259   struct VULKAN_HPP_DEPRECATED(
1260     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDebugUtilsMessengerEXT>
1261   {
1262     using type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;
1263   };
1264 
1265   template <>
1266   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT>
1267   {
1268     using Type = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT;
1269   };
1270 
1271   template <>
1272   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>
1273   {
1274     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1275   };
1276 
1277   class DisplayKHR
1278   {
1279   public:
1280     using CType = VkDisplayKHR;
1281 
1282     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1283       VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR;
1284     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1285       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR;
1286 
1287   public:
1288     VULKAN_HPP_CONSTEXPR         DisplayKHR() = default;
DisplayKHR(std::nullptr_t)1289     VULKAN_HPP_CONSTEXPR         DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DisplayKHR(VkDisplayKHR displayKHR)1290     VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT : m_displayKHR( displayKHR )
1291     {}
1292 
1293 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDisplayKHR displayKHR)1294     DisplayKHR & operator=( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT
1295     {
1296       m_displayKHR = displayKHR;
1297       return *this;
1298     }
1299 #endif
1300 
operator =(std::nullptr_t)1301     DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1302     {
1303       m_displayKHR = {};
1304       return *this;
1305     }
1306 
1307 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1308     auto operator<=>( DisplayKHR const & ) const = default;
1309 #else
operator ==(DisplayKHR const & rhs) const1310     bool operator==( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1311     {
1312       return m_displayKHR == rhs.m_displayKHR;
1313     }
1314 
operator !=(DisplayKHR const & rhs) const1315     bool operator!=( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1316     {
1317       return m_displayKHR != rhs.m_displayKHR;
1318     }
1319 
operator <(DisplayKHR const & rhs) const1320     bool operator<( DisplayKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1321     {
1322       return m_displayKHR < rhs.m_displayKHR;
1323     }
1324 #endif
1325 
operator VkDisplayKHR() const1326     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const VULKAN_HPP_NOEXCEPT
1327     {
1328       return m_displayKHR;
1329     }
1330 
operator bool() const1331     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1332     {
1333       return m_displayKHR != VK_NULL_HANDLE;
1334     }
1335 
operator !() const1336     bool operator!() const VULKAN_HPP_NOEXCEPT
1337     {
1338       return m_displayKHR == VK_NULL_HANDLE;
1339     }
1340 
1341   private:
1342     VkDisplayKHR m_displayKHR = {};
1343   };
1344   static_assert( sizeof( VULKAN_HPP_NAMESPACE::DisplayKHR ) == sizeof( VkDisplayKHR ),
1345                  "handle and wrapper have different size!" );
1346 
1347   template <>
1348   struct VULKAN_HPP_DEPRECATED(
1349     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDisplayKHR>
1350   {
1351     using type = VULKAN_HPP_NAMESPACE::DisplayKHR;
1352   };
1353 
1354   template <>
1355   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR>
1356   {
1357     using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
1358   };
1359 
1360   template <>
1361   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
1362                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR>
1363   {
1364     using Type = VULKAN_HPP_NAMESPACE::DisplayKHR;
1365   };
1366 
1367   template <>
1368   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayKHR>
1369   {
1370     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1371   };
1372 
1373   class SwapchainKHR
1374   {
1375   public:
1376     using CType = VkSwapchainKHR;
1377 
1378     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1379       VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR;
1380     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1381       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR;
1382 
1383   public:
1384     VULKAN_HPP_CONSTEXPR         SwapchainKHR() = default;
SwapchainKHR(std::nullptr_t)1385     VULKAN_HPP_CONSTEXPR         SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
SwapchainKHR(VkSwapchainKHR swapchainKHR)1386     VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT
1387       : m_swapchainKHR( swapchainKHR )
1388     {}
1389 
1390 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkSwapchainKHR swapchainKHR)1391     SwapchainKHR & operator=( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT
1392     {
1393       m_swapchainKHR = swapchainKHR;
1394       return *this;
1395     }
1396 #endif
1397 
operator =(std::nullptr_t)1398     SwapchainKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1399     {
1400       m_swapchainKHR = {};
1401       return *this;
1402     }
1403 
1404 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1405     auto operator<=>( SwapchainKHR const & ) const = default;
1406 #else
operator ==(SwapchainKHR const & rhs) const1407     bool operator==( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1408     {
1409       return m_swapchainKHR == rhs.m_swapchainKHR;
1410     }
1411 
operator !=(SwapchainKHR const & rhs) const1412     bool operator!=( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1413     {
1414       return m_swapchainKHR != rhs.m_swapchainKHR;
1415     }
1416 
operator <(SwapchainKHR const & rhs) const1417     bool operator<( SwapchainKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
1418     {
1419       return m_swapchainKHR < rhs.m_swapchainKHR;
1420     }
1421 #endif
1422 
operator VkSwapchainKHR() const1423     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const VULKAN_HPP_NOEXCEPT
1424     {
1425       return m_swapchainKHR;
1426     }
1427 
operator bool() const1428     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1429     {
1430       return m_swapchainKHR != VK_NULL_HANDLE;
1431     }
1432 
operator !() const1433     bool operator!() const VULKAN_HPP_NOEXCEPT
1434     {
1435       return m_swapchainKHR == VK_NULL_HANDLE;
1436     }
1437 
1438   private:
1439     VkSwapchainKHR m_swapchainKHR = {};
1440   };
1441   static_assert( sizeof( VULKAN_HPP_NAMESPACE::SwapchainKHR ) == sizeof( VkSwapchainKHR ),
1442                  "handle and wrapper have different size!" );
1443 
1444   template <>
1445   struct VULKAN_HPP_DEPRECATED(
1446     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSwapchainKHR>
1447   {
1448     using type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
1449   };
1450 
1451   template <>
1452   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR>
1453   {
1454     using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
1455   };
1456 
1457   template <>
1458   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
1459                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR>
1460   {
1461     using Type = VULKAN_HPP_NAMESPACE::SwapchainKHR;
1462   };
1463 
1464   template <>
1465   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SwapchainKHR>
1466   {
1467     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1468   };
1469 
1470   class Semaphore
1471   {
1472   public:
1473     using CType = VkSemaphore;
1474 
1475     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1476       VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore;
1477     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1478       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore;
1479 
1480   public:
1481     VULKAN_HPP_CONSTEXPR         Semaphore() = default;
Semaphore(std::nullptr_t)1482     VULKAN_HPP_CONSTEXPR         Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Semaphore(VkSemaphore semaphore)1483     VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT : m_semaphore( semaphore ) {}
1484 
1485 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkSemaphore semaphore)1486     Semaphore & operator=( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT
1487     {
1488       m_semaphore = semaphore;
1489       return *this;
1490     }
1491 #endif
1492 
operator =(std::nullptr_t)1493     Semaphore & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1494     {
1495       m_semaphore = {};
1496       return *this;
1497     }
1498 
1499 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1500     auto operator<=>( Semaphore const & ) const = default;
1501 #else
operator ==(Semaphore const & rhs) const1502     bool operator==( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
1503     {
1504       return m_semaphore == rhs.m_semaphore;
1505     }
1506 
operator !=(Semaphore const & rhs) const1507     bool operator!=( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
1508     {
1509       return m_semaphore != rhs.m_semaphore;
1510     }
1511 
operator <(Semaphore const & rhs) const1512     bool operator<( Semaphore const & rhs ) const VULKAN_HPP_NOEXCEPT
1513     {
1514       return m_semaphore < rhs.m_semaphore;
1515     }
1516 #endif
1517 
operator VkSemaphore() const1518     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const VULKAN_HPP_NOEXCEPT
1519     {
1520       return m_semaphore;
1521     }
1522 
operator bool() const1523     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1524     {
1525       return m_semaphore != VK_NULL_HANDLE;
1526     }
1527 
operator !() const1528     bool operator!() const VULKAN_HPP_NOEXCEPT
1529     {
1530       return m_semaphore == VK_NULL_HANDLE;
1531     }
1532 
1533   private:
1534     VkSemaphore m_semaphore = {};
1535   };
1536   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Semaphore ) == sizeof( VkSemaphore ),
1537                  "handle and wrapper have different size!" );
1538 
1539   template <>
1540   struct VULKAN_HPP_DEPRECATED(
1541     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSemaphore>
1542   {
1543     using type = VULKAN_HPP_NAMESPACE::Semaphore;
1544   };
1545 
1546   template <>
1547   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore>
1548   {
1549     using Type = VULKAN_HPP_NAMESPACE::Semaphore;
1550   };
1551 
1552   template <>
1553   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
1554                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore>
1555   {
1556     using Type = VULKAN_HPP_NAMESPACE::Semaphore;
1557   };
1558 
1559   template <>
1560   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Semaphore>
1561   {
1562     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1563   };
1564 
1565   class Fence
1566   {
1567   public:
1568     using CType = VkFence;
1569 
1570     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1571       VULKAN_HPP_NAMESPACE::ObjectType::eFence;
1572     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1573       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence;
1574 
1575   public:
1576     VULKAN_HPP_CONSTEXPR         Fence() = default;
Fence(std::nullptr_t)1577     VULKAN_HPP_CONSTEXPR         Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Fence(VkFence fence)1578     VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT : m_fence( fence ) {}
1579 
1580 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkFence fence)1581     Fence & operator=( VkFence fence ) VULKAN_HPP_NOEXCEPT
1582     {
1583       m_fence = fence;
1584       return *this;
1585     }
1586 #endif
1587 
operator =(std::nullptr_t)1588     Fence & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1589     {
1590       m_fence = {};
1591       return *this;
1592     }
1593 
1594 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1595     auto operator<=>( Fence const & ) const = default;
1596 #else
operator ==(Fence const & rhs) const1597     bool operator==( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
1598     {
1599       return m_fence == rhs.m_fence;
1600     }
1601 
operator !=(Fence const & rhs) const1602     bool operator!=( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
1603     {
1604       return m_fence != rhs.m_fence;
1605     }
1606 
operator <(Fence const & rhs) const1607     bool operator<( Fence const & rhs ) const VULKAN_HPP_NOEXCEPT
1608     {
1609       return m_fence < rhs.m_fence;
1610     }
1611 #endif
1612 
operator VkFence() const1613     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const VULKAN_HPP_NOEXCEPT
1614     {
1615       return m_fence;
1616     }
1617 
operator bool() const1618     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1619     {
1620       return m_fence != VK_NULL_HANDLE;
1621     }
1622 
operator !() const1623     bool operator!() const VULKAN_HPP_NOEXCEPT
1624     {
1625       return m_fence == VK_NULL_HANDLE;
1626     }
1627 
1628   private:
1629     VkFence m_fence = {};
1630   };
1631   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Fence ) == sizeof( VkFence ),
1632                  "handle and wrapper have different size!" );
1633 
1634   template <>
1635   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eFence>
1636   {
1637     using type = VULKAN_HPP_NAMESPACE::Fence;
1638   };
1639 
1640   template <>
1641   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFence>
1642   {
1643     using Type = VULKAN_HPP_NAMESPACE::Fence;
1644   };
1645 
1646   template <>
1647   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence>
1648   {
1649     using Type = VULKAN_HPP_NAMESPACE::Fence;
1650   };
1651 
1652   template <>
1653   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Fence>
1654   {
1655     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1656   };
1657 
1658   class PerformanceConfigurationINTEL
1659   {
1660   public:
1661     using CType = VkPerformanceConfigurationINTEL;
1662 
1663     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1664       VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL;
1665     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1666       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
1667 
1668   public:
1669     VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL() = default;
PerformanceConfigurationINTEL(std::nullptr_t)1670     VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
1671     VULKAN_HPP_TYPESAFE_EXPLICIT
PerformanceConfigurationINTEL(VkPerformanceConfigurationINTEL performanceConfigurationINTEL)1672       PerformanceConfigurationINTEL( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
1673       : m_performanceConfigurationINTEL( performanceConfigurationINTEL )
1674     {}
1675 
1676 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
1677     PerformanceConfigurationINTEL &
operator =(VkPerformanceConfigurationINTEL performanceConfigurationINTEL)1678       operator=( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT
1679     {
1680       m_performanceConfigurationINTEL = performanceConfigurationINTEL;
1681       return *this;
1682     }
1683 #endif
1684 
operator =(std::nullptr_t)1685     PerformanceConfigurationINTEL & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1686     {
1687       m_performanceConfigurationINTEL = {};
1688       return *this;
1689     }
1690 
1691 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1692     auto operator<=>( PerformanceConfigurationINTEL const & ) const = default;
1693 #else
operator ==(PerformanceConfigurationINTEL const & rhs) const1694     bool operator==( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
1695     {
1696       return m_performanceConfigurationINTEL == rhs.m_performanceConfigurationINTEL;
1697     }
1698 
operator !=(PerformanceConfigurationINTEL const & rhs) const1699     bool operator!=( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
1700     {
1701       return m_performanceConfigurationINTEL != rhs.m_performanceConfigurationINTEL;
1702     }
1703 
operator <(PerformanceConfigurationINTEL const & rhs) const1704     bool operator<( PerformanceConfigurationINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
1705     {
1706       return m_performanceConfigurationINTEL < rhs.m_performanceConfigurationINTEL;
1707     }
1708 #endif
1709 
operator VkPerformanceConfigurationINTEL() const1710     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT
1711     {
1712       return m_performanceConfigurationINTEL;
1713     }
1714 
operator bool() const1715     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1716     {
1717       return m_performanceConfigurationINTEL != VK_NULL_HANDLE;
1718     }
1719 
operator !() const1720     bool operator!() const VULKAN_HPP_NOEXCEPT
1721     {
1722       return m_performanceConfigurationINTEL == VK_NULL_HANDLE;
1723     }
1724 
1725   private:
1726     VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {};
1727   };
1728   static_assert( sizeof( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL ) ==
1729                    sizeof( VkPerformanceConfigurationINTEL ),
1730                  "handle and wrapper have different size!" );
1731 
1732   template <>
1733   struct VULKAN_HPP_DEPRECATED(
1734     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePerformanceConfigurationINTEL>
1735   {
1736     using type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;
1737   };
1738 
1739   template <>
1740   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL>
1741   {
1742     using Type = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL;
1743   };
1744 
1745   template <>
1746   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>
1747   {
1748     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1749   };
1750 
1751   class QueryPool
1752   {
1753   public:
1754     using CType = VkQueryPool;
1755 
1756     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1757       VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool;
1758     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1759       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool;
1760 
1761   public:
1762     VULKAN_HPP_CONSTEXPR         QueryPool() = default;
QueryPool(std::nullptr_t)1763     VULKAN_HPP_CONSTEXPR         QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
QueryPool(VkQueryPool queryPool)1764     VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT : m_queryPool( queryPool ) {}
1765 
1766 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkQueryPool queryPool)1767     QueryPool & operator=( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT
1768     {
1769       m_queryPool = queryPool;
1770       return *this;
1771     }
1772 #endif
1773 
operator =(std::nullptr_t)1774     QueryPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1775     {
1776       m_queryPool = {};
1777       return *this;
1778     }
1779 
1780 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1781     auto operator<=>( QueryPool const & ) const = default;
1782 #else
operator ==(QueryPool const & rhs) const1783     bool operator==( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
1784     {
1785       return m_queryPool == rhs.m_queryPool;
1786     }
1787 
operator !=(QueryPool const & rhs) const1788     bool operator!=( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
1789     {
1790       return m_queryPool != rhs.m_queryPool;
1791     }
1792 
operator <(QueryPool const & rhs) const1793     bool operator<( QueryPool const & rhs ) const VULKAN_HPP_NOEXCEPT
1794     {
1795       return m_queryPool < rhs.m_queryPool;
1796     }
1797 #endif
1798 
operator VkQueryPool() const1799     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const VULKAN_HPP_NOEXCEPT
1800     {
1801       return m_queryPool;
1802     }
1803 
operator bool() const1804     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1805     {
1806       return m_queryPool != VK_NULL_HANDLE;
1807     }
1808 
operator !() const1809     bool operator!() const VULKAN_HPP_NOEXCEPT
1810     {
1811       return m_queryPool == VK_NULL_HANDLE;
1812     }
1813 
1814   private:
1815     VkQueryPool m_queryPool = {};
1816   };
1817   static_assert( sizeof( VULKAN_HPP_NAMESPACE::QueryPool ) == sizeof( VkQueryPool ),
1818                  "handle and wrapper have different size!" );
1819 
1820   template <>
1821   struct VULKAN_HPP_DEPRECATED(
1822     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eQueryPool>
1823   {
1824     using type = VULKAN_HPP_NAMESPACE::QueryPool;
1825   };
1826 
1827   template <>
1828   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool>
1829   {
1830     using Type = VULKAN_HPP_NAMESPACE::QueryPool;
1831   };
1832 
1833   template <>
1834   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
1835                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool>
1836   {
1837     using Type = VULKAN_HPP_NAMESPACE::QueryPool;
1838   };
1839 
1840   template <>
1841   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::QueryPool>
1842   {
1843     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1844   };
1845 
1846   class Buffer
1847   {
1848   public:
1849     using CType = VkBuffer;
1850 
1851     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1852       VULKAN_HPP_NAMESPACE::ObjectType::eBuffer;
1853     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1854       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer;
1855 
1856   public:
1857     VULKAN_HPP_CONSTEXPR         Buffer() = default;
Buffer(std::nullptr_t)1858     VULKAN_HPP_CONSTEXPR         Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Buffer(VkBuffer buffer)1859     VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT : m_buffer( buffer ) {}
1860 
1861 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkBuffer buffer)1862     Buffer & operator=( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT
1863     {
1864       m_buffer = buffer;
1865       return *this;
1866     }
1867 #endif
1868 
operator =(std::nullptr_t)1869     Buffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1870     {
1871       m_buffer = {};
1872       return *this;
1873     }
1874 
1875 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1876     auto operator<=>( Buffer const & ) const = default;
1877 #else
operator ==(Buffer const & rhs) const1878     bool operator==( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
1879     {
1880       return m_buffer == rhs.m_buffer;
1881     }
1882 
operator !=(Buffer const & rhs) const1883     bool operator!=( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
1884     {
1885       return m_buffer != rhs.m_buffer;
1886     }
1887 
operator <(Buffer const & rhs) const1888     bool operator<( Buffer const & rhs ) const VULKAN_HPP_NOEXCEPT
1889     {
1890       return m_buffer < rhs.m_buffer;
1891     }
1892 #endif
1893 
operator VkBuffer() const1894     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const VULKAN_HPP_NOEXCEPT
1895     {
1896       return m_buffer;
1897     }
1898 
operator bool() const1899     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1900     {
1901       return m_buffer != VK_NULL_HANDLE;
1902     }
1903 
operator !() const1904     bool operator!() const VULKAN_HPP_NOEXCEPT
1905     {
1906       return m_buffer == VK_NULL_HANDLE;
1907     }
1908 
1909   private:
1910     VkBuffer m_buffer = {};
1911   };
1912   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Buffer ) == sizeof( VkBuffer ),
1913                  "handle and wrapper have different size!" );
1914 
1915   template <>
1916   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eBuffer>
1917   {
1918     using type = VULKAN_HPP_NAMESPACE::Buffer;
1919   };
1920 
1921   template <>
1922   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBuffer>
1923   {
1924     using Type = VULKAN_HPP_NAMESPACE::Buffer;
1925   };
1926 
1927   template <>
1928   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
1929                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer>
1930   {
1931     using Type = VULKAN_HPP_NAMESPACE::Buffer;
1932   };
1933 
1934   template <>
1935   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Buffer>
1936   {
1937     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
1938   };
1939 
1940   class PipelineLayout
1941   {
1942   public:
1943     using CType = VkPipelineLayout;
1944 
1945     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
1946       VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout;
1947     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
1948       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout;
1949 
1950   public:
1951     VULKAN_HPP_CONSTEXPR         PipelineLayout() = default;
PipelineLayout(std::nullptr_t)1952     VULKAN_HPP_CONSTEXPR         PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
PipelineLayout(VkPipelineLayout pipelineLayout)1953     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT
1954       : m_pipelineLayout( pipelineLayout )
1955     {}
1956 
1957 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkPipelineLayout pipelineLayout)1958     PipelineLayout & operator=( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT
1959     {
1960       m_pipelineLayout = pipelineLayout;
1961       return *this;
1962     }
1963 #endif
1964 
operator =(std::nullptr_t)1965     PipelineLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
1966     {
1967       m_pipelineLayout = {};
1968       return *this;
1969     }
1970 
1971 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
1972     auto operator<=>( PipelineLayout const & ) const = default;
1973 #else
operator ==(PipelineLayout const & rhs) const1974     bool operator==( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
1975     {
1976       return m_pipelineLayout == rhs.m_pipelineLayout;
1977     }
1978 
operator !=(PipelineLayout const & rhs) const1979     bool operator!=( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
1980     {
1981       return m_pipelineLayout != rhs.m_pipelineLayout;
1982     }
1983 
operator <(PipelineLayout const & rhs) const1984     bool operator<( PipelineLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
1985     {
1986       return m_pipelineLayout < rhs.m_pipelineLayout;
1987     }
1988 #endif
1989 
operator VkPipelineLayout() const1990     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const VULKAN_HPP_NOEXCEPT
1991     {
1992       return m_pipelineLayout;
1993     }
1994 
operator bool() const1995     explicit operator bool() const VULKAN_HPP_NOEXCEPT
1996     {
1997       return m_pipelineLayout != VK_NULL_HANDLE;
1998     }
1999 
operator !() const2000     bool operator!() const VULKAN_HPP_NOEXCEPT
2001     {
2002       return m_pipelineLayout == VK_NULL_HANDLE;
2003     }
2004 
2005   private:
2006     VkPipelineLayout m_pipelineLayout = {};
2007   };
2008   static_assert( sizeof( VULKAN_HPP_NAMESPACE::PipelineLayout ) == sizeof( VkPipelineLayout ),
2009                  "handle and wrapper have different size!" );
2010 
2011   template <>
2012   struct VULKAN_HPP_DEPRECATED(
2013     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePipelineLayout>
2014   {
2015     using type = VULKAN_HPP_NAMESPACE::PipelineLayout;
2016   };
2017 
2018   template <>
2019   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout>
2020   {
2021     using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
2022   };
2023 
2024   template <>
2025   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2026                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout>
2027   {
2028     using Type = VULKAN_HPP_NAMESPACE::PipelineLayout;
2029   };
2030 
2031   template <>
2032   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineLayout>
2033   {
2034     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2035   };
2036 
2037   class DescriptorSet
2038   {
2039   public:
2040     using CType = VkDescriptorSet;
2041 
2042     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2043       VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet;
2044     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2045       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet;
2046 
2047   public:
2048     VULKAN_HPP_CONSTEXPR         DescriptorSet() = default;
DescriptorSet(std::nullptr_t)2049     VULKAN_HPP_CONSTEXPR         DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DescriptorSet(VkDescriptorSet descriptorSet)2050     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT
2051       : m_descriptorSet( descriptorSet )
2052     {}
2053 
2054 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDescriptorSet descriptorSet)2055     DescriptorSet & operator=( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT
2056     {
2057       m_descriptorSet = descriptorSet;
2058       return *this;
2059     }
2060 #endif
2061 
operator =(std::nullptr_t)2062     DescriptorSet & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2063     {
2064       m_descriptorSet = {};
2065       return *this;
2066     }
2067 
2068 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2069     auto operator<=>( DescriptorSet const & ) const = default;
2070 #else
operator ==(DescriptorSet const & rhs) const2071     bool operator==( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2072     {
2073       return m_descriptorSet == rhs.m_descriptorSet;
2074     }
2075 
operator !=(DescriptorSet const & rhs) const2076     bool operator!=( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2077     {
2078       return m_descriptorSet != rhs.m_descriptorSet;
2079     }
2080 
operator <(DescriptorSet const & rhs) const2081     bool operator<( DescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
2082     {
2083       return m_descriptorSet < rhs.m_descriptorSet;
2084     }
2085 #endif
2086 
operator VkDescriptorSet() const2087     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const VULKAN_HPP_NOEXCEPT
2088     {
2089       return m_descriptorSet;
2090     }
2091 
operator bool() const2092     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2093     {
2094       return m_descriptorSet != VK_NULL_HANDLE;
2095     }
2096 
operator !() const2097     bool operator!() const VULKAN_HPP_NOEXCEPT
2098     {
2099       return m_descriptorSet == VK_NULL_HANDLE;
2100     }
2101 
2102   private:
2103     VkDescriptorSet m_descriptorSet = {};
2104   };
2105   static_assert( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSet ) == sizeof( VkDescriptorSet ),
2106                  "handle and wrapper have different size!" );
2107 
2108   template <>
2109   struct VULKAN_HPP_DEPRECATED(
2110     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDescriptorSet>
2111   {
2112     using type = VULKAN_HPP_NAMESPACE::DescriptorSet;
2113   };
2114 
2115   template <>
2116   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet>
2117   {
2118     using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
2119   };
2120 
2121   template <>
2122   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2123                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet>
2124   {
2125     using Type = VULKAN_HPP_NAMESPACE::DescriptorSet;
2126   };
2127 
2128   template <>
2129   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSet>
2130   {
2131     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2132   };
2133 
2134   class Pipeline
2135   {
2136   public:
2137     using CType = VkPipeline;
2138 
2139     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2140       VULKAN_HPP_NAMESPACE::ObjectType::ePipeline;
2141     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2142       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline;
2143 
2144   public:
2145     VULKAN_HPP_CONSTEXPR         Pipeline() = default;
Pipeline(std::nullptr_t)2146     VULKAN_HPP_CONSTEXPR         Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Pipeline(VkPipeline pipeline)2147     VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT : m_pipeline( pipeline ) {}
2148 
2149 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkPipeline pipeline)2150     Pipeline & operator=( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT
2151     {
2152       m_pipeline = pipeline;
2153       return *this;
2154     }
2155 #endif
2156 
operator =(std::nullptr_t)2157     Pipeline & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2158     {
2159       m_pipeline = {};
2160       return *this;
2161     }
2162 
2163 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2164     auto operator<=>( Pipeline const & ) const = default;
2165 #else
operator ==(Pipeline const & rhs) const2166     bool operator==( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
2167     {
2168       return m_pipeline == rhs.m_pipeline;
2169     }
2170 
operator !=(Pipeline const & rhs) const2171     bool operator!=( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
2172     {
2173       return m_pipeline != rhs.m_pipeline;
2174     }
2175 
operator <(Pipeline const & rhs) const2176     bool operator<( Pipeline const & rhs ) const VULKAN_HPP_NOEXCEPT
2177     {
2178       return m_pipeline < rhs.m_pipeline;
2179     }
2180 #endif
2181 
operator VkPipeline() const2182     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const VULKAN_HPP_NOEXCEPT
2183     {
2184       return m_pipeline;
2185     }
2186 
operator bool() const2187     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2188     {
2189       return m_pipeline != VK_NULL_HANDLE;
2190     }
2191 
operator !() const2192     bool operator!() const VULKAN_HPP_NOEXCEPT
2193     {
2194       return m_pipeline == VK_NULL_HANDLE;
2195     }
2196 
2197   private:
2198     VkPipeline m_pipeline = {};
2199   };
2200   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Pipeline ) == sizeof( VkPipeline ),
2201                  "handle and wrapper have different size!" );
2202 
2203   template <>
2204   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePipeline>
2205   {
2206     using type = VULKAN_HPP_NAMESPACE::Pipeline;
2207   };
2208 
2209   template <>
2210   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipeline>
2211   {
2212     using Type = VULKAN_HPP_NAMESPACE::Pipeline;
2213   };
2214 
2215   template <>
2216   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2217                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline>
2218   {
2219     using Type = VULKAN_HPP_NAMESPACE::Pipeline;
2220   };
2221 
2222   template <>
2223   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Pipeline>
2224   {
2225     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2226   };
2227 
2228   class ImageView
2229   {
2230   public:
2231     using CType = VkImageView;
2232 
2233     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2234       VULKAN_HPP_NAMESPACE::ObjectType::eImageView;
2235     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2236       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView;
2237 
2238   public:
2239     VULKAN_HPP_CONSTEXPR         ImageView() = default;
ImageView(std::nullptr_t)2240     VULKAN_HPP_CONSTEXPR         ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
ImageView(VkImageView imageView)2241     VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT : m_imageView( imageView ) {}
2242 
2243 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkImageView imageView)2244     ImageView & operator=( VkImageView imageView ) VULKAN_HPP_NOEXCEPT
2245     {
2246       m_imageView = imageView;
2247       return *this;
2248     }
2249 #endif
2250 
operator =(std::nullptr_t)2251     ImageView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2252     {
2253       m_imageView = {};
2254       return *this;
2255     }
2256 
2257 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2258     auto operator<=>( ImageView const & ) const = default;
2259 #else
operator ==(ImageView const & rhs) const2260     bool operator==( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
2261     {
2262       return m_imageView == rhs.m_imageView;
2263     }
2264 
operator !=(ImageView const & rhs) const2265     bool operator!=( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
2266     {
2267       return m_imageView != rhs.m_imageView;
2268     }
2269 
operator <(ImageView const & rhs) const2270     bool operator<( ImageView const & rhs ) const VULKAN_HPP_NOEXCEPT
2271     {
2272       return m_imageView < rhs.m_imageView;
2273     }
2274 #endif
2275 
operator VkImageView() const2276     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const VULKAN_HPP_NOEXCEPT
2277     {
2278       return m_imageView;
2279     }
2280 
operator bool() const2281     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2282     {
2283       return m_imageView != VK_NULL_HANDLE;
2284     }
2285 
operator !() const2286     bool operator!() const VULKAN_HPP_NOEXCEPT
2287     {
2288       return m_imageView == VK_NULL_HANDLE;
2289     }
2290 
2291   private:
2292     VkImageView m_imageView = {};
2293   };
2294   static_assert( sizeof( VULKAN_HPP_NAMESPACE::ImageView ) == sizeof( VkImageView ),
2295                  "handle and wrapper have different size!" );
2296 
2297   template <>
2298   struct VULKAN_HPP_DEPRECATED(
2299     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eImageView>
2300   {
2301     using type = VULKAN_HPP_NAMESPACE::ImageView;
2302   };
2303 
2304   template <>
2305   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImageView>
2306   {
2307     using Type = VULKAN_HPP_NAMESPACE::ImageView;
2308   };
2309 
2310   template <>
2311   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2312                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView>
2313   {
2314     using Type = VULKAN_HPP_NAMESPACE::ImageView;
2315   };
2316 
2317   template <>
2318   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ImageView>
2319   {
2320     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2321   };
2322 
2323   class Image
2324   {
2325   public:
2326     using CType = VkImage;
2327 
2328     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2329       VULKAN_HPP_NAMESPACE::ObjectType::eImage;
2330     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2331       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage;
2332 
2333   public:
2334     VULKAN_HPP_CONSTEXPR         Image() = default;
Image(std::nullptr_t)2335     VULKAN_HPP_CONSTEXPR         Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Image(VkImage image)2336     VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT : m_image( image ) {}
2337 
2338 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkImage image)2339     Image & operator=( VkImage image ) VULKAN_HPP_NOEXCEPT
2340     {
2341       m_image = image;
2342       return *this;
2343     }
2344 #endif
2345 
operator =(std::nullptr_t)2346     Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2347     {
2348       m_image = {};
2349       return *this;
2350     }
2351 
2352 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2353     auto operator<=>( Image const & ) const = default;
2354 #else
operator ==(Image const & rhs) const2355     bool operator==( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
2356     {
2357       return m_image == rhs.m_image;
2358     }
2359 
operator !=(Image const & rhs) const2360     bool operator!=( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
2361     {
2362       return m_image != rhs.m_image;
2363     }
2364 
operator <(Image const & rhs) const2365     bool operator<( Image const & rhs ) const VULKAN_HPP_NOEXCEPT
2366     {
2367       return m_image < rhs.m_image;
2368     }
2369 #endif
2370 
operator VkImage() const2371     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const VULKAN_HPP_NOEXCEPT
2372     {
2373       return m_image;
2374     }
2375 
operator bool() const2376     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2377     {
2378       return m_image != VK_NULL_HANDLE;
2379     }
2380 
operator !() const2381     bool operator!() const VULKAN_HPP_NOEXCEPT
2382     {
2383       return m_image == VK_NULL_HANDLE;
2384     }
2385 
2386   private:
2387     VkImage m_image = {};
2388   };
2389   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Image ) == sizeof( VkImage ),
2390                  "handle and wrapper have different size!" );
2391 
2392   template <>
2393   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eImage>
2394   {
2395     using type = VULKAN_HPP_NAMESPACE::Image;
2396   };
2397 
2398   template <>
2399   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eImage>
2400   {
2401     using Type = VULKAN_HPP_NAMESPACE::Image;
2402   };
2403 
2404   template <>
2405   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage>
2406   {
2407     using Type = VULKAN_HPP_NAMESPACE::Image;
2408   };
2409 
2410   template <>
2411   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Image>
2412   {
2413     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2414   };
2415 
2416   class AccelerationStructureNV
2417   {
2418   public:
2419     using CType = VkAccelerationStructureNV;
2420 
2421     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2422       VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV;
2423     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2424       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV;
2425 
2426   public:
2427     VULKAN_HPP_CONSTEXPR AccelerationStructureNV() = default;
AccelerationStructureNV(std::nullptr_t)2428     VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2429     VULKAN_HPP_TYPESAFE_EXPLICIT
AccelerationStructureNV(VkAccelerationStructureNV accelerationStructureNV)2430       AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
2431       : m_accelerationStructureNV( accelerationStructureNV )
2432     {}
2433 
2434 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkAccelerationStructureNV accelerationStructureNV)2435     AccelerationStructureNV & operator=( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT
2436     {
2437       m_accelerationStructureNV = accelerationStructureNV;
2438       return *this;
2439     }
2440 #endif
2441 
operator =(std::nullptr_t)2442     AccelerationStructureNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2443     {
2444       m_accelerationStructureNV = {};
2445       return *this;
2446     }
2447 
2448 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2449     auto operator<=>( AccelerationStructureNV const & ) const = default;
2450 #else
operator ==(AccelerationStructureNV const & rhs) const2451     bool operator==( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
2452     {
2453       return m_accelerationStructureNV == rhs.m_accelerationStructureNV;
2454     }
2455 
operator !=(AccelerationStructureNV const & rhs) const2456     bool operator!=( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
2457     {
2458       return m_accelerationStructureNV != rhs.m_accelerationStructureNV;
2459     }
2460 
operator <(AccelerationStructureNV const & rhs) const2461     bool operator<( AccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
2462     {
2463       return m_accelerationStructureNV < rhs.m_accelerationStructureNV;
2464     }
2465 #endif
2466 
operator VkAccelerationStructureNV() const2467     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const VULKAN_HPP_NOEXCEPT
2468     {
2469       return m_accelerationStructureNV;
2470     }
2471 
operator bool() const2472     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2473     {
2474       return m_accelerationStructureNV != VK_NULL_HANDLE;
2475     }
2476 
operator !() const2477     bool operator!() const VULKAN_HPP_NOEXCEPT
2478     {
2479       return m_accelerationStructureNV == VK_NULL_HANDLE;
2480     }
2481 
2482   private:
2483     VkAccelerationStructureNV m_accelerationStructureNV = {};
2484   };
2485   static_assert( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureNV ) == sizeof( VkAccelerationStructureNV ),
2486                  "handle and wrapper have different size!" );
2487 
2488   template <>
2489   struct VULKAN_HPP_DEPRECATED(
2490     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eAccelerationStructureNV>
2491   {
2492     using type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
2493   };
2494 
2495   template <>
2496   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV>
2497   {
2498     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
2499   };
2500 
2501   template <>
2502   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2503                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV>
2504   {
2505     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureNV;
2506   };
2507 
2508   template <>
2509   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>
2510   {
2511     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2512   };
2513 
2514   class DescriptorUpdateTemplate
2515   {
2516   public:
2517     using CType = VkDescriptorUpdateTemplate;
2518 
2519     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2520       VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate;
2521     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2522       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate;
2523 
2524   public:
2525     VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate() = default;
DescriptorUpdateTemplate(std::nullptr_t)2526     VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2527     VULKAN_HPP_TYPESAFE_EXPLICIT
DescriptorUpdateTemplate(VkDescriptorUpdateTemplate descriptorUpdateTemplate)2528       DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
2529       : m_descriptorUpdateTemplate( descriptorUpdateTemplate )
2530     {}
2531 
2532 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDescriptorUpdateTemplate descriptorUpdateTemplate)2533     DescriptorUpdateTemplate & operator=( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT
2534     {
2535       m_descriptorUpdateTemplate = descriptorUpdateTemplate;
2536       return *this;
2537     }
2538 #endif
2539 
operator =(std::nullptr_t)2540     DescriptorUpdateTemplate & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2541     {
2542       m_descriptorUpdateTemplate = {};
2543       return *this;
2544     }
2545 
2546 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2547     auto operator<=>( DescriptorUpdateTemplate const & ) const = default;
2548 #else
operator ==(DescriptorUpdateTemplate const & rhs) const2549     bool operator==( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
2550     {
2551       return m_descriptorUpdateTemplate == rhs.m_descriptorUpdateTemplate;
2552     }
2553 
operator !=(DescriptorUpdateTemplate const & rhs) const2554     bool operator!=( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
2555     {
2556       return m_descriptorUpdateTemplate != rhs.m_descriptorUpdateTemplate;
2557     }
2558 
operator <(DescriptorUpdateTemplate const & rhs) const2559     bool operator<( DescriptorUpdateTemplate const & rhs ) const VULKAN_HPP_NOEXCEPT
2560     {
2561       return m_descriptorUpdateTemplate < rhs.m_descriptorUpdateTemplate;
2562     }
2563 #endif
2564 
operator VkDescriptorUpdateTemplate() const2565     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT
2566     {
2567       return m_descriptorUpdateTemplate;
2568     }
2569 
operator bool() const2570     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2571     {
2572       return m_descriptorUpdateTemplate != VK_NULL_HANDLE;
2573     }
2574 
operator !() const2575     bool operator!() const VULKAN_HPP_NOEXCEPT
2576     {
2577       return m_descriptorUpdateTemplate == VK_NULL_HANDLE;
2578     }
2579 
2580   private:
2581     VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {};
2582   };
2583   static_assert( sizeof( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ),
2584                  "handle and wrapper have different size!" );
2585 
2586   template <>
2587   struct VULKAN_HPP_DEPRECATED(
2588     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDescriptorUpdateTemplate>
2589   {
2590     using type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
2591   };
2592 
2593   template <>
2594   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate>
2595   {
2596     using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
2597   };
2598 
2599   template <>
2600   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2601                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate>
2602   {
2603     using Type = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate;
2604   };
2605 
2606   template <>
2607   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
2608   {
2609     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2610   };
2611   using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
2612 
2613   class Event
2614   {
2615   public:
2616     using CType = VkEvent;
2617 
2618     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2619       VULKAN_HPP_NAMESPACE::ObjectType::eEvent;
2620     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2621       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent;
2622 
2623   public:
2624     VULKAN_HPP_CONSTEXPR         Event() = default;
Event(std::nullptr_t)2625     VULKAN_HPP_CONSTEXPR         Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Event(VkEvent event)2626     VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) VULKAN_HPP_NOEXCEPT : m_event( event ) {}
2627 
2628 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkEvent event)2629     Event & operator=( VkEvent event ) VULKAN_HPP_NOEXCEPT
2630     {
2631       m_event = event;
2632       return *this;
2633     }
2634 #endif
2635 
operator =(std::nullptr_t)2636     Event & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2637     {
2638       m_event = {};
2639       return *this;
2640     }
2641 
2642 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2643     auto operator<=>( Event const & ) const = default;
2644 #else
operator ==(Event const & rhs) const2645     bool operator==( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
2646     {
2647       return m_event == rhs.m_event;
2648     }
2649 
operator !=(Event const & rhs) const2650     bool operator!=( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
2651     {
2652       return m_event != rhs.m_event;
2653     }
2654 
operator <(Event const & rhs) const2655     bool operator<( Event const & rhs ) const VULKAN_HPP_NOEXCEPT
2656     {
2657       return m_event < rhs.m_event;
2658     }
2659 #endif
2660 
operator VkEvent() const2661     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const VULKAN_HPP_NOEXCEPT
2662     {
2663       return m_event;
2664     }
2665 
operator bool() const2666     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2667     {
2668       return m_event != VK_NULL_HANDLE;
2669     }
2670 
operator !() const2671     bool operator!() const VULKAN_HPP_NOEXCEPT
2672     {
2673       return m_event == VK_NULL_HANDLE;
2674     }
2675 
2676   private:
2677     VkEvent m_event = {};
2678   };
2679   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Event ) == sizeof( VkEvent ),
2680                  "handle and wrapper have different size!" );
2681 
2682   template <>
2683   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eEvent>
2684   {
2685     using type = VULKAN_HPP_NAMESPACE::Event;
2686   };
2687 
2688   template <>
2689   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eEvent>
2690   {
2691     using Type = VULKAN_HPP_NAMESPACE::Event;
2692   };
2693 
2694   template <>
2695   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent>
2696   {
2697     using Type = VULKAN_HPP_NAMESPACE::Event;
2698   };
2699 
2700   template <>
2701   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Event>
2702   {
2703     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2704   };
2705 
2706   class AccelerationStructureKHR
2707   {
2708   public:
2709     using CType = VkAccelerationStructureKHR;
2710 
2711     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2712       VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR;
2713     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2714       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR;
2715 
2716   public:
2717     VULKAN_HPP_CONSTEXPR AccelerationStructureKHR() = default;
AccelerationStructureKHR(std::nullptr_t)2718     VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
2719     VULKAN_HPP_TYPESAFE_EXPLICIT
AccelerationStructureKHR(VkAccelerationStructureKHR accelerationStructureKHR)2720       AccelerationStructureKHR( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
2721       : m_accelerationStructureKHR( accelerationStructureKHR )
2722     {}
2723 
2724 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkAccelerationStructureKHR accelerationStructureKHR)2725     AccelerationStructureKHR & operator=( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT
2726     {
2727       m_accelerationStructureKHR = accelerationStructureKHR;
2728       return *this;
2729     }
2730 #endif
2731 
operator =(std::nullptr_t)2732     AccelerationStructureKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2733     {
2734       m_accelerationStructureKHR = {};
2735       return *this;
2736     }
2737 
2738 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2739     auto operator<=>( AccelerationStructureKHR const & ) const = default;
2740 #else
operator ==(AccelerationStructureKHR const & rhs) const2741     bool operator==( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2742     {
2743       return m_accelerationStructureKHR == rhs.m_accelerationStructureKHR;
2744     }
2745 
operator !=(AccelerationStructureKHR const & rhs) const2746     bool operator!=( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2747     {
2748       return m_accelerationStructureKHR != rhs.m_accelerationStructureKHR;
2749     }
2750 
operator <(AccelerationStructureKHR const & rhs) const2751     bool operator<( AccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
2752     {
2753       return m_accelerationStructureKHR < rhs.m_accelerationStructureKHR;
2754     }
2755 #endif
2756 
operator VkAccelerationStructureKHR() const2757     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT
2758     {
2759       return m_accelerationStructureKHR;
2760     }
2761 
operator bool() const2762     explicit operator bool() const VULKAN_HPP_NOEXCEPT
2763     {
2764       return m_accelerationStructureKHR != VK_NULL_HANDLE;
2765     }
2766 
operator !() const2767     bool operator!() const VULKAN_HPP_NOEXCEPT
2768     {
2769       return m_accelerationStructureKHR == VK_NULL_HANDLE;
2770     }
2771 
2772   private:
2773     VkAccelerationStructureKHR m_accelerationStructureKHR = {};
2774   };
2775   static_assert( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR ) == sizeof( VkAccelerationStructureKHR ),
2776                  "handle and wrapper have different size!" );
2777 
2778   template <>
2779   struct VULKAN_HPP_DEPRECATED(
2780     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eAccelerationStructureKHR>
2781   {
2782     using type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
2783   };
2784 
2785   template <>
2786   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR>
2787   {
2788     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
2789   };
2790 
2791   template <>
2792   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
2793                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR>
2794   {
2795     using Type = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR;
2796   };
2797 
2798   template <>
2799   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>
2800   {
2801     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
2802   };
2803 
2804   class CommandBuffer
2805   {
2806   public:
2807     using CType = VkCommandBuffer;
2808 
2809     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
2810       VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer;
2811     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
2812       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer;
2813 
2814   public:
2815     VULKAN_HPP_CONSTEXPR         CommandBuffer() = default;
CommandBuffer(std::nullptr_t)2816     VULKAN_HPP_CONSTEXPR         CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
CommandBuffer(VkCommandBuffer commandBuffer)2817     VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT
2818       : m_commandBuffer( commandBuffer )
2819     {}
2820 
2821 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkCommandBuffer commandBuffer)2822     CommandBuffer & operator=( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT
2823     {
2824       m_commandBuffer = commandBuffer;
2825       return *this;
2826     }
2827 #endif
2828 
operator =(std::nullptr_t)2829     CommandBuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
2830     {
2831       m_commandBuffer = {};
2832       return *this;
2833     }
2834 
2835 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
2836     auto operator<=>( CommandBuffer const & ) const = default;
2837 #else
operator ==(CommandBuffer const & rhs) const2838     bool operator==( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
2839     {
2840       return m_commandBuffer == rhs.m_commandBuffer;
2841     }
2842 
operator !=(CommandBuffer const & rhs) const2843     bool operator!=( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
2844     {
2845       return m_commandBuffer != rhs.m_commandBuffer;
2846     }
2847 
operator <(CommandBuffer const & rhs) const2848     bool operator<( CommandBuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
2849     {
2850       return m_commandBuffer < rhs.m_commandBuffer;
2851     }
2852 #endif
2853 
2854     //=== VK_VERSION_1_0 ===
2855 
2856     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2857     VULKAN_HPP_NODISCARD Result
2858                          begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo * pBeginInfo,
2859                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2860 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2861     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2862     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
2863       begin( const CommandBufferBeginInfo & beginInfo,
2864              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
2865 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
2866 
2867 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
2868     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2869     VULKAN_HPP_NODISCARD Result
2870                          end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2871 #else
2872     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2873     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
2874       end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
2875 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
2876 
2877 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
2878     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2879     VULKAN_HPP_NODISCARD Result
2880                          reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags,
2881                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2882 #else
2883     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2884     typename ResultValueType<void>::type
2885          reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
2886                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
2887 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
2888 
2889     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2890     void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
2891                        VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
2892                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2893 
2894     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2895     void setViewport( uint32_t                               firstViewport,
2896                       uint32_t                               viewportCount,
2897                       const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
2898                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2899 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2900     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2901     void setViewport( uint32_t                                                 firstViewport,
2902                       ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
2903                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2904 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
2905 
2906     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2907     void setScissor( uint32_t                             firstScissor,
2908                      uint32_t                             scissorCount,
2909                      const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
2910                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2911 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2912     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2913     void setScissor( uint32_t                                               firstScissor,
2914                      ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
2915                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2916 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
2917 
2918     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2919     void setLineWidth( float            lineWidth,
2920                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2921 
2922     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2923     void setDepthBias( float            depthBiasConstantFactor,
2924                        float            depthBiasClamp,
2925                        float            depthBiasSlopeFactor,
2926                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2927 
2928     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2929     void setBlendConstants( const float      blendConstants[4],
2930                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2931 
2932     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2933     void setDepthBounds( float            minDepthBounds,
2934                          float            maxDepthBounds,
2935                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2936 
2937     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2938     void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
2939                                 uint32_t                               compareMask,
2940                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2941 
2942     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2943     void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
2944                               uint32_t                               writeMask,
2945                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2946 
2947     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2948     void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
2949                               uint32_t                               reference,
2950                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2951 
2952     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2953     void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint     pipelineBindPoint,
2954                              VULKAN_HPP_NAMESPACE::PipelineLayout        layout,
2955                              uint32_t                                    firstSet,
2956                              uint32_t                                    descriptorSetCount,
2957                              const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
2958                              uint32_t                                    dynamicOffsetCount,
2959                              const uint32_t *                            pDynamicOffsets,
2960                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2961 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2962     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2963     void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint                       pipelineBindPoint,
2964                              VULKAN_HPP_NAMESPACE::PipelineLayout                          layout,
2965                              uint32_t                                                      firstSet,
2966                              ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
2967                              ArrayProxy<const uint32_t> const &                            dynamicOffsets,
2968                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2969 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
2970 
2971     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2972     void bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer     buffer,
2973                           VULKAN_HPP_NAMESPACE::DeviceSize offset,
2974                           VULKAN_HPP_NAMESPACE::IndexType  indexType,
2975                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2976 
2977     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2978     void bindVertexBuffers( uint32_t                                 firstBinding,
2979                             uint32_t                                 bindingCount,
2980                             const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
2981                             const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
2982                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2983 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
2984     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2985     void bindVertexBuffers( uint32_t                                                   firstBinding,
2986                             ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
2987                             ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
2988                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
2989       VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
2990 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
2991 
2992     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
2993     void draw( uint32_t         vertexCount,
2994                uint32_t         instanceCount,
2995                uint32_t         firstVertex,
2996                uint32_t         firstInstance,
2997                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
2998 
2999     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3000     void drawIndexed( uint32_t         indexCount,
3001                       uint32_t         instanceCount,
3002                       uint32_t         firstIndex,
3003                       int32_t          vertexOffset,
3004                       uint32_t         firstInstance,
3005                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3006 
3007     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3008     void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3009                        VULKAN_HPP_NAMESPACE::DeviceSize offset,
3010                        uint32_t                         drawCount,
3011                        uint32_t                         stride,
3012                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3013 
3014     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3015     void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3016                               VULKAN_HPP_NAMESPACE::DeviceSize offset,
3017                               uint32_t                         drawCount,
3018                               uint32_t                         stride,
3019                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3020 
3021     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3022     void dispatch( uint32_t         groupCountX,
3023                    uint32_t         groupCountY,
3024                    uint32_t         groupCountZ,
3025                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3026 
3027     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3028     void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3029                            VULKAN_HPP_NAMESPACE::DeviceSize offset,
3030                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3031 
3032     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3033     void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer             srcBuffer,
3034                      VULKAN_HPP_NAMESPACE::Buffer             dstBuffer,
3035                      uint32_t                                 regionCount,
3036                      const VULKAN_HPP_NAMESPACE::BufferCopy * pRegions,
3037                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3038 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3039     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3040     void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer                               srcBuffer,
3041                      VULKAN_HPP_NAMESPACE::Buffer                               dstBuffer,
3042                      ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions,
3043                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3044 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3045 
3046     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3047     void copyImage( VULKAN_HPP_NAMESPACE::Image             srcImage,
3048                     VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,
3049                     VULKAN_HPP_NAMESPACE::Image             dstImage,
3050                     VULKAN_HPP_NAMESPACE::ImageLayout       dstImageLayout,
3051                     uint32_t                                regionCount,
3052                     const VULKAN_HPP_NAMESPACE::ImageCopy * pRegions,
3053                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3054 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3055     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3056     void copyImage( VULKAN_HPP_NAMESPACE::Image                               srcImage,
3057                     VULKAN_HPP_NAMESPACE::ImageLayout                         srcImageLayout,
3058                     VULKAN_HPP_NAMESPACE::Image                               dstImage,
3059                     VULKAN_HPP_NAMESPACE::ImageLayout                         dstImageLayout,
3060                     ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions,
3061                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3062 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3063 
3064     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3065     void blitImage( VULKAN_HPP_NAMESPACE::Image             srcImage,
3066                     VULKAN_HPP_NAMESPACE::ImageLayout       srcImageLayout,
3067                     VULKAN_HPP_NAMESPACE::Image             dstImage,
3068                     VULKAN_HPP_NAMESPACE::ImageLayout       dstImageLayout,
3069                     uint32_t                                regionCount,
3070                     const VULKAN_HPP_NAMESPACE::ImageBlit * pRegions,
3071                     VULKAN_HPP_NAMESPACE::Filter            filter,
3072                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3073 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3074     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3075     void blitImage( VULKAN_HPP_NAMESPACE::Image                               srcImage,
3076                     VULKAN_HPP_NAMESPACE::ImageLayout                         srcImageLayout,
3077                     VULKAN_HPP_NAMESPACE::Image                               dstImage,
3078                     VULKAN_HPP_NAMESPACE::ImageLayout                         dstImageLayout,
3079                     ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions,
3080                     VULKAN_HPP_NAMESPACE::Filter                              filter,
3081                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3082 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3083 
3084     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3085     void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                  srcBuffer,
3086                             VULKAN_HPP_NAMESPACE::Image                   dstImage,
3087                             VULKAN_HPP_NAMESPACE::ImageLayout             dstImageLayout,
3088                             uint32_t                                      regionCount,
3089                             const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
3090                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3091 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3092     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3093     void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer                                    srcBuffer,
3094                             VULKAN_HPP_NAMESPACE::Image                                     dstImage,
3095                             VULKAN_HPP_NAMESPACE::ImageLayout                               dstImageLayout,
3096                             ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
3097                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3098 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3099 
3100     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3101     void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                   srcImage,
3102                             VULKAN_HPP_NAMESPACE::ImageLayout             srcImageLayout,
3103                             VULKAN_HPP_NAMESPACE::Buffer                  dstBuffer,
3104                             uint32_t                                      regionCount,
3105                             const VULKAN_HPP_NAMESPACE::BufferImageCopy * pRegions,
3106                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3107 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3108     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3109     void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image                                     srcImage,
3110                             VULKAN_HPP_NAMESPACE::ImageLayout                               srcImageLayout,
3111                             VULKAN_HPP_NAMESPACE::Buffer                                    dstBuffer,
3112                             ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions,
3113                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3114 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3115 
3116     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3117     void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
3118                        VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
3119                        VULKAN_HPP_NAMESPACE::DeviceSize dataSize,
3120                        const void *                     pData,
3121                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3122 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3123     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3124     void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
3125                        VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
3126                        ArrayProxy<const T> const &      data,
3127                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3128 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3129 
3130     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3131     void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer     dstBuffer,
3132                      VULKAN_HPP_NAMESPACE::DeviceSize dstOffset,
3133                      VULKAN_HPP_NAMESPACE::DeviceSize size,
3134                      uint32_t                         data,
3135                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3136 
3137     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3138     void clearColorImage( VULKAN_HPP_NAMESPACE::Image                         image,
3139                           VULKAN_HPP_NAMESPACE::ImageLayout                   imageLayout,
3140                           const VULKAN_HPP_NAMESPACE::ClearColorValue *       pColor,
3141                           uint32_t                                            rangeCount,
3142                           const VULKAN_HPP_NAMESPACE::ImageSubresourceRange * pRanges,
3143                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3144 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3145     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3146     void clearColorImage( VULKAN_HPP_NAMESPACE::Image                                           image,
3147                           VULKAN_HPP_NAMESPACE::ImageLayout                                     imageLayout,
3148                           const ClearColorValue &                                               color,
3149                           ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,
3150                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3151 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3152 
3153     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3154     void
3155       clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image                          image,
3156                               VULKAN_HPP_NAMESPACE::ImageLayout                    imageLayout,
3157                               const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue * pDepthStencil,
3158                               uint32_t                                             rangeCount,
3159                               const VULKAN_HPP_NAMESPACE::ImageSubresourceRange *  pRanges,
3160                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3161 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3162     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3163     void
3164       clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image                                           image,
3165                               VULKAN_HPP_NAMESPACE::ImageLayout                                     imageLayout,
3166                               const ClearDepthStencilValue &                                        depthStencil,
3167                               ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges,
3168                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3169 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3170 
3171     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3172     void clearAttachments( uint32_t                                      attachmentCount,
3173                            const VULKAN_HPP_NAMESPACE::ClearAttachment * pAttachments,
3174                            uint32_t                                      rectCount,
3175                            const VULKAN_HPP_NAMESPACE::ClearRect *       pRects,
3176                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3177 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3178     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3179     void clearAttachments( ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,
3180                            ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const &       rects,
3181                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3182 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3183 
3184     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3185     void resolveImage( VULKAN_HPP_NAMESPACE::Image                srcImage,
3186                        VULKAN_HPP_NAMESPACE::ImageLayout          srcImageLayout,
3187                        VULKAN_HPP_NAMESPACE::Image                dstImage,
3188                        VULKAN_HPP_NAMESPACE::ImageLayout          dstImageLayout,
3189                        uint32_t                                   regionCount,
3190                        const VULKAN_HPP_NAMESPACE::ImageResolve * pRegions,
3191                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3192 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3193     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3194     void resolveImage( VULKAN_HPP_NAMESPACE::Image                                  srcImage,
3195                        VULKAN_HPP_NAMESPACE::ImageLayout                            srcImageLayout,
3196                        VULKAN_HPP_NAMESPACE::Image                                  dstImage,
3197                        VULKAN_HPP_NAMESPACE::ImageLayout                            dstImageLayout,
3198                        ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions,
3199                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3200 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3201 
3202     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3203     void setEvent( VULKAN_HPP_NAMESPACE::Event              event,
3204                    VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
3205                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3206 
3207     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3208     void resetEvent( VULKAN_HPP_NAMESPACE::Event              event,
3209                      VULKAN_HPP_NAMESPACE::PipelineStageFlags stageMask,
3210                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3211 
3212     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3213     void waitEvents( uint32_t                                          eventCount,
3214                      const VULKAN_HPP_NAMESPACE::Event *               pEvents,
3215                      VULKAN_HPP_NAMESPACE::PipelineStageFlags          srcStageMask,
3216                      VULKAN_HPP_NAMESPACE::PipelineStageFlags          dstStageMask,
3217                      uint32_t                                          memoryBarrierCount,
3218                      const VULKAN_HPP_NAMESPACE::MemoryBarrier *       pMemoryBarriers,
3219                      uint32_t                                          bufferMemoryBarrierCount,
3220                      const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
3221                      uint32_t                                          imageMemoryBarrierCount,
3222                      const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *  pImageMemoryBarriers,
3223                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3224 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3225     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3226     void waitEvents( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &               events,
3227                      VULKAN_HPP_NAMESPACE::PipelineStageFlags                            srcStageMask,
3228                      VULKAN_HPP_NAMESPACE::PipelineStageFlags                            dstStageMask,
3229                      ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
3230                      ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
3231                      ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers,
3232                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3233 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3234 
3235     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3236     void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags          srcStageMask,
3237                           VULKAN_HPP_NAMESPACE::PipelineStageFlags          dstStageMask,
3238                           VULKAN_HPP_NAMESPACE::DependencyFlags             dependencyFlags,
3239                           uint32_t                                          memoryBarrierCount,
3240                           const VULKAN_HPP_NAMESPACE::MemoryBarrier *       pMemoryBarriers,
3241                           uint32_t                                          bufferMemoryBarrierCount,
3242                           const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier * pBufferMemoryBarriers,
3243                           uint32_t                                          imageMemoryBarrierCount,
3244                           const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier *  pImageMemoryBarriers,
3245                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3246 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3247     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3248     void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags                            srcStageMask,
3249                           VULKAN_HPP_NAMESPACE::PipelineStageFlags                            dstStageMask,
3250                           VULKAN_HPP_NAMESPACE::DependencyFlags                               dependencyFlags,
3251                           ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const &       memoryBarriers,
3252                           ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
3253                           ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const &  imageMemoryBarriers,
3254                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3255 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3256 
3257     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3258     void beginQuery( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
3259                      uint32_t                                query,
3260                      VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
3261                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3262 
3263     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3264     void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
3265                    uint32_t                        query,
3266                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3267 
3268     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3269     void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
3270                          uint32_t                        firstQuery,
3271                          uint32_t                        queryCount,
3272                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3273 
3274     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3275     void writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
3276                          VULKAN_HPP_NAMESPACE::QueryPool             queryPool,
3277                          uint32_t                                    query,
3278                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3279 
3280     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3281     void copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
3282                                uint32_t                               firstQuery,
3283                                uint32_t                               queryCount,
3284                                VULKAN_HPP_NAMESPACE::Buffer           dstBuffer,
3285                                VULKAN_HPP_NAMESPACE::DeviceSize       dstOffset,
3286                                VULKAN_HPP_NAMESPACE::DeviceSize       stride,
3287                                VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
3288                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3289 
3290     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3291     void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
3292                         VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
3293                         uint32_t                               offset,
3294                         uint32_t                               size,
3295                         const void *                           pValues,
3296                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3297 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3298     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3299     void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout   layout,
3300                         VULKAN_HPP_NAMESPACE::ShaderStageFlags stageFlags,
3301                         uint32_t                               offset,
3302                         ArrayProxy<const T> const &            values,
3303                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3304 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3305 
3306     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3307     void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
3308                           VULKAN_HPP_NAMESPACE::SubpassContents             contents,
3309                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3310 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3311     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3312     void beginRenderPass( const RenderPassBeginInfo &           renderPassBegin,
3313                           VULKAN_HPP_NAMESPACE::SubpassContents contents,
3314                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3315 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3316 
3317     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3318     void nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents,
3319                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3320 
3321     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3322     void endRenderPass( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3323 
3324     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3325     void executeCommands( uint32_t                                    commandBufferCount,
3326                           const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
3327                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3328 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3329     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3330     void executeCommands( ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
3331                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3332 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3333 
3334     //=== VK_VERSION_1_1 ===
3335 
3336     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3337     void setDeviceMask( uint32_t         deviceMask,
3338                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3339 
3340     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3341     void dispatchBase( uint32_t         baseGroupX,
3342                        uint32_t         baseGroupY,
3343                        uint32_t         baseGroupZ,
3344                        uint32_t         groupCountX,
3345                        uint32_t         groupCountY,
3346                        uint32_t         groupCountZ,
3347                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3348 
3349     //=== VK_VERSION_1_2 ===
3350 
3351     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3352     void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3353                             VULKAN_HPP_NAMESPACE::DeviceSize offset,
3354                             VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
3355                             VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
3356                             uint32_t                         maxDrawCount,
3357                             uint32_t                         stride,
3358                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3359 
3360     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3361     void
3362       drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3363                                 VULKAN_HPP_NAMESPACE::DeviceSize offset,
3364                                 VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
3365                                 VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
3366                                 uint32_t                         maxDrawCount,
3367                                 uint32_t                         stride,
3368                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3369 
3370     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3371     void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
3372                            const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,
3373                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3374 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3375     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3376     void beginRenderPass2( const RenderPassBeginInfo & renderPassBegin,
3377                            const SubpassBeginInfo &    subpassBeginInfo,
3378                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3379 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3380 
3381     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3382     void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
3383                        const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,
3384                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3385 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3386     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3387     void nextSubpass2( const SubpassBeginInfo & subpassBeginInfo,
3388                        const SubpassEndInfo &   subpassEndInfo,
3389                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3390 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3391 
3392     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3393     void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
3394                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3395 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3396     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3397     void endRenderPass2( const SubpassEndInfo & subpassEndInfo,
3398                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3399 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3400 
3401     //=== VK_EXT_debug_marker ===
3402 
3403     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3404     void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
3405                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3406 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3407     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3408     void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo,
3409                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3410 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3411 
3412     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3413     void debugMarkerEndEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3414 
3415     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3416     void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT * pMarkerInfo,
3417                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3418 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3419     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3420     void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo,
3421                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3422 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3423 
3424 #if defined( VK_ENABLE_BETA_EXTENSIONS )
3425     //=== VK_KHR_video_queue ===
3426 
3427     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3428     void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR * pBeginInfo,
3429                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3430 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3431     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3432     void beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo,
3433                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3434 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3435 
3436     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3437     void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR * pEndCodingInfo,
3438                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3439 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3440     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3441     void endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo,
3442                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3443 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3444 
3445     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3446     void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR * pCodingControlInfo,
3447                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3448 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3449     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3450     void controlVideoCodingKHR( const VideoCodingControlInfoKHR & codingControlInfo,
3451                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3452 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3453 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
3454 
3455 #if defined( VK_ENABLE_BETA_EXTENSIONS )
3456     //=== VK_KHR_video_decode_queue ===
3457 
3458     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3459     void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR * pFrameInfo,
3460                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3461 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3462     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3463     void decodeVideoKHR( const VideoDecodeInfoKHR & frameInfo,
3464                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3465 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3466 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
3467 
3468     //=== VK_EXT_transform_feedback ===
3469 
3470     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3471     void bindTransformFeedbackBuffersEXT( uint32_t                                 firstBinding,
3472                                           uint32_t                                 bindingCount,
3473                                           const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
3474                                           const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
3475                                           const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
3476                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3477       VULKAN_HPP_NOEXCEPT;
3478 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3479     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3480     void bindTransformFeedbackBuffersEXT(
3481       uint32_t                                                   firstBinding,
3482       ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
3483       ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
3484       ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
3485       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
3486 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3487 
3488     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3489     void beginTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,
3490                                     uint32_t                                 counterBufferCount,
3491                                     const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,
3492                                     const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
3493                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3494       VULKAN_HPP_NOEXCEPT;
3495 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3496     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3497     void beginTransformFeedbackEXT( uint32_t                                                   firstCounterBuffer,
3498                                     ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     counterBuffers,
3499                                     ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
3500                                                                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
3501                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3502       VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
3503 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3504 
3505     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3506     void
3507       endTransformFeedbackEXT( uint32_t                                 firstCounterBuffer,
3508                                uint32_t                                 counterBufferCount,
3509                                const VULKAN_HPP_NAMESPACE::Buffer *     pCounterBuffers,
3510                                const VULKAN_HPP_NAMESPACE::DeviceSize * pCounterBufferOffsets,
3511                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3512 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3513     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3514     void endTransformFeedbackEXT( uint32_t                                                   firstCounterBuffer,
3515                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     counterBuffers,
3516                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
3517                                                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
3518                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3519       VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
3520 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3521 
3522     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3523     void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool         queryPool,
3524                                uint32_t                                query,
3525                                VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
3526                                uint32_t                                index,
3527                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3528 
3529     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3530     void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
3531                              uint32_t                        query,
3532                              uint32_t                        index,
3533                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3534 
3535     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3536     void
3537       drawIndirectByteCountEXT( uint32_t                         instanceCount,
3538                                 uint32_t                         firstInstance,
3539                                 VULKAN_HPP_NAMESPACE::Buffer     counterBuffer,
3540                                 VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
3541                                 uint32_t                         counterOffset,
3542                                 uint32_t                         vertexStride,
3543                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3544 
3545     //=== VK_NVX_binary_import ===
3546 
3547     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3548     void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX * pLaunchInfo,
3549                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3550 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3551     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3552     void cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo,
3553                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3554 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3555 
3556     //=== VK_AMD_draw_indirect_count ===
3557 
3558     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3559     void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3560                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
3561                                VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
3562                                VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
3563                                uint32_t                         maxDrawCount,
3564                                uint32_t                         stride,
3565                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3566 
3567     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3568     void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3569                                       VULKAN_HPP_NAMESPACE::DeviceSize offset,
3570                                       VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
3571                                       VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
3572                                       uint32_t                         maxDrawCount,
3573                                       uint32_t                         stride,
3574                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3575       VULKAN_HPP_NOEXCEPT;
3576 
3577     //=== VK_KHR_device_group ===
3578 
3579     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3580     void setDeviceMaskKHR( uint32_t         deviceMask,
3581                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3582 
3583     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3584     void dispatchBaseKHR( uint32_t         baseGroupX,
3585                           uint32_t         baseGroupY,
3586                           uint32_t         baseGroupZ,
3587                           uint32_t         groupCountX,
3588                           uint32_t         groupCountY,
3589                           uint32_t         groupCountZ,
3590                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3591 
3592     //=== VK_KHR_push_descriptor ===
3593 
3594     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3595     void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint          pipelineBindPoint,
3596                                VULKAN_HPP_NAMESPACE::PipelineLayout             layout,
3597                                uint32_t                                         set,
3598                                uint32_t                                         descriptorWriteCount,
3599                                const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
3600                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3601 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3602     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3603     void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint                            pipelineBindPoint,
3604                                VULKAN_HPP_NAMESPACE::PipelineLayout                               layout,
3605                                uint32_t                                                           set,
3606                                ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
3607                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3608 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3609 
3610     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3611     void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
3612                                            VULKAN_HPP_NAMESPACE::PipelineLayout           layout,
3613                                            uint32_t                                       set,
3614                                            const void *                                   pData,
3615                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3616       VULKAN_HPP_NOEXCEPT;
3617 
3618     //=== VK_EXT_conditional_rendering ===
3619 
3620     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3621     void beginConditionalRenderingEXT(
3622       const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin,
3623       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3624 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3625     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3626     void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin,
3627                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3628       VULKAN_HPP_NOEXCEPT;
3629 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3630 
3631     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3632     void endConditionalRenderingEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3633       VULKAN_HPP_NOEXCEPT;
3634 
3635     //=== VK_NV_clip_space_w_scaling ===
3636 
3637     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3638     void setViewportWScalingNV( uint32_t                                         firstViewport,
3639                                 uint32_t                                         viewportCount,
3640                                 const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * pViewportWScalings,
3641                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3642 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3643     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3644     void setViewportWScalingNV( uint32_t                                                           firstViewport,
3645                                 ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings,
3646                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3647 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3648 
3649     //=== VK_EXT_discard_rectangles ===
3650 
3651     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3652     void
3653       setDiscardRectangleEXT( uint32_t                             firstDiscardRectangle,
3654                               uint32_t                             discardRectangleCount,
3655                               const VULKAN_HPP_NAMESPACE::Rect2D * pDiscardRectangles,
3656                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3657 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3658     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3659     void
3660       setDiscardRectangleEXT( uint32_t                                               firstDiscardRectangle,
3661                               ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles,
3662                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3663 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3664 
3665     //=== VK_KHR_create_renderpass2 ===
3666 
3667     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3668     void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo * pRenderPassBegin,
3669                               const VULKAN_HPP_NAMESPACE::SubpassBeginInfo *    pSubpassBeginInfo,
3670                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3671 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3672     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3673     void beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin,
3674                               const SubpassBeginInfo &    subpassBeginInfo,
3675                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3676 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3677 
3678     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3679     void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo * pSubpassBeginInfo,
3680                           const VULKAN_HPP_NAMESPACE::SubpassEndInfo *   pSubpassEndInfo,
3681                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3682 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3683     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3684     void nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo,
3685                           const SubpassEndInfo &   subpassEndInfo,
3686                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3687 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3688 
3689     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3690     void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo * pSubpassEndInfo,
3691                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3692 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3693     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3694     void endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo,
3695                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3696 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3697 
3698     //=== VK_EXT_debug_utils ===
3699 
3700     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3701     void
3702       beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
3703                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3704 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3705     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3706     void
3707       beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
3708                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3709 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3710 
3711     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3712     void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3713 
3714     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3715     void
3716       insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
3717                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3718 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3719     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3720     void
3721       insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
3722                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3723 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3724 
3725     //=== VK_EXT_sample_locations ===
3726 
3727     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3728     void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT * pSampleLocationsInfo,
3729                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3730 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3731     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3732     void setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo,
3733                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3734 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3735 
3736     //=== VK_KHR_acceleration_structure ===
3737 
3738     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3739     void buildAccelerationStructuresKHR(
3740       uint32_t                                                                     infoCount,
3741       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,
3742       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
3743       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3744 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3745     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3746     void buildAccelerationStructuresKHR(
3747       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
3748       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
3749       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
3750 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3751 
3752     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3753     void buildAccelerationStructuresIndirectKHR(
3754       uint32_t                                                                infoCount,
3755       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pInfos,
3756       const VULKAN_HPP_NAMESPACE::DeviceAddress *                             pIndirectDeviceAddresses,
3757       const uint32_t *                                                        pIndirectStrides,
3758       const uint32_t * const *                                                ppMaxPrimitiveCounts,
3759       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3760 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3761     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3762     void buildAccelerationStructuresIndirectKHR(
3763       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
3764       ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const &                             indirectDeviceAddresses,
3765       ArrayProxy<const uint32_t> const &                                                        indirectStrides,
3766       ArrayProxy<const uint32_t * const> const &                                                pMaxPrimitiveCounts,
3767       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
3768 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3769 
3770     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3771     void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
3772                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3773       VULKAN_HPP_NOEXCEPT;
3774 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3775     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3776     void copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info,
3777                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3778       VULKAN_HPP_NOEXCEPT;
3779 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3780 
3781     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3782     void copyAccelerationStructureToMemoryKHR(
3783       const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
3784       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3785 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3786     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3787     void copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR & info,
3788                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3789       VULKAN_HPP_NOEXCEPT;
3790 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3791 
3792     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3793     void copyMemoryToAccelerationStructureKHR(
3794       const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
3795       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3796 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3797     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3798     void copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR & info,
3799                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3800       VULKAN_HPP_NOEXCEPT;
3801 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3802 
3803     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3804     void writeAccelerationStructuresPropertiesKHR(
3805       uint32_t                                               accelerationStructureCount,
3806       const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
3807       VULKAN_HPP_NAMESPACE::QueryType                        queryType,
3808       VULKAN_HPP_NAMESPACE::QueryPool                        queryPool,
3809       uint32_t                                               firstQuery,
3810       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3811 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3812     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3813     void writeAccelerationStructuresPropertiesKHR(
3814       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
3815       VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
3816       VULKAN_HPP_NAMESPACE::QueryPool                                          queryPool,
3817       uint32_t                                                                 firstQuery,
3818       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3819 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3820 
3821     //=== VK_NV_shading_rate_image ===
3822 
3823     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3824     void
3825       bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView   imageView,
3826                               VULKAN_HPP_NAMESPACE::ImageLayout imageLayout,
3827                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3828 
3829     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3830     void setViewportShadingRatePaletteNV( uint32_t                                           firstViewport,
3831                                           uint32_t                                           viewportCount,
3832                                           const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * pShadingRatePalettes,
3833                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3834       VULKAN_HPP_NOEXCEPT;
3835 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3836     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3837     void setViewportShadingRatePaletteNV(
3838       uint32_t                                                             firstViewport,
3839       ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes,
3840       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3841 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3842 
3843     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3844     void
3845       setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV           sampleOrderType,
3846                               uint32_t                                                customSampleOrderCount,
3847                               const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * pCustomSampleOrders,
3848                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3849 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3850     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3851     void setCoarseSampleOrderNV(
3852       VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV                             sampleOrderType,
3853       ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders,
3854       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3855 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3856 
3857     //=== VK_NV_ray_tracing ===
3858 
3859     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3860     void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV * pInfo,
3861                                        VULKAN_HPP_NAMESPACE::Buffer                              instanceData,
3862                                        VULKAN_HPP_NAMESPACE::DeviceSize                          instanceOffset,
3863                                        VULKAN_HPP_NAMESPACE::Bool32                              update,
3864                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             dst,
3865                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV             src,
3866                                        VULKAN_HPP_NAMESPACE::Buffer                              scratch,
3867                                        VULKAN_HPP_NAMESPACE::DeviceSize                          scratchOffset,
3868                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3869       VULKAN_HPP_NOEXCEPT;
3870 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3871     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3872     void buildAccelerationStructureNV( const AccelerationStructureInfoNV &           info,
3873                                        VULKAN_HPP_NAMESPACE::Buffer                  instanceData,
3874                                        VULKAN_HPP_NAMESPACE::DeviceSize              instanceOffset,
3875                                        VULKAN_HPP_NAMESPACE::Bool32                  update,
3876                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
3877                                        VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
3878                                        VULKAN_HPP_NAMESPACE::Buffer                  scratch,
3879                                        VULKAN_HPP_NAMESPACE::DeviceSize              scratchOffset,
3880                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3881       VULKAN_HPP_NOEXCEPT;
3882 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3883 
3884     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3885     void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV          dst,
3886                                       VULKAN_HPP_NAMESPACE::AccelerationStructureNV          src,
3887                                       VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR mode,
3888                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3889       VULKAN_HPP_NOEXCEPT;
3890 
3891     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3892     void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer     raygenShaderBindingTableBuffer,
3893                       VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,
3894                       VULKAN_HPP_NAMESPACE::Buffer     missShaderBindingTableBuffer,
3895                       VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,
3896                       VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,
3897                       VULKAN_HPP_NAMESPACE::Buffer     hitShaderBindingTableBuffer,
3898                       VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,
3899                       VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,
3900                       VULKAN_HPP_NAMESPACE::Buffer     callableShaderBindingTableBuffer,
3901                       VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,
3902                       VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,
3903                       uint32_t                         width,
3904                       uint32_t                         height,
3905                       uint32_t                         depth,
3906                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3907 
3908     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3909     void writeAccelerationStructuresPropertiesNV(
3910       uint32_t                                              accelerationStructureCount,
3911       const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * pAccelerationStructures,
3912       VULKAN_HPP_NAMESPACE::QueryType                       queryType,
3913       VULKAN_HPP_NAMESPACE::QueryPool                       queryPool,
3914       uint32_t                                              firstQuery,
3915       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3916 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3917     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3918     void writeAccelerationStructuresPropertiesNV(
3919       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures,
3920       VULKAN_HPP_NAMESPACE::QueryType                                         queryType,
3921       VULKAN_HPP_NAMESPACE::QueryPool                                         queryPool,
3922       uint32_t                                                                firstQuery,
3923       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3924 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3925 
3926     //=== VK_KHR_draw_indirect_count ===
3927 
3928     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3929     void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3930                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
3931                                VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
3932                                VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
3933                                uint32_t                         maxDrawCount,
3934                                uint32_t                         stride,
3935                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3936 
3937     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3938     void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3939                                       VULKAN_HPP_NAMESPACE::DeviceSize offset,
3940                                       VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
3941                                       VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
3942                                       uint32_t                         maxDrawCount,
3943                                       uint32_t                         stride,
3944                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3945       VULKAN_HPP_NOEXCEPT;
3946 
3947     //=== VK_AMD_buffer_marker ===
3948 
3949     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3950     void writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
3951                                VULKAN_HPP_NAMESPACE::Buffer                dstBuffer,
3952                                VULKAN_HPP_NAMESPACE::DeviceSize            dstOffset,
3953                                uint32_t                                    marker,
3954                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3955 
3956     //=== VK_NV_mesh_shader ===
3957 
3958     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3959     void drawMeshTasksNV( uint32_t         taskCount,
3960                           uint32_t         firstTask,
3961                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3962 
3963     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3964     void
3965       drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3966                                VULKAN_HPP_NAMESPACE::DeviceSize offset,
3967                                uint32_t                         drawCount,
3968                                uint32_t                         stride,
3969                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3970 
3971     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3972     void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer     buffer,
3973                                        VULKAN_HPP_NAMESPACE::DeviceSize offset,
3974                                        VULKAN_HPP_NAMESPACE::Buffer     countBuffer,
3975                                        VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
3976                                        uint32_t                         maxDrawCount,
3977                                        uint32_t                         stride,
3978                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
3979       VULKAN_HPP_NOEXCEPT;
3980 
3981     //=== VK_NV_scissor_exclusive ===
3982 
3983     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3984     void setExclusiveScissorNV( uint32_t                             firstExclusiveScissor,
3985                                 uint32_t                             exclusiveScissorCount,
3986                                 const VULKAN_HPP_NAMESPACE::Rect2D * pExclusiveScissors,
3987                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3988 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
3989     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3990     void setExclusiveScissorNV( uint32_t                                               firstExclusiveScissor,
3991                                 ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors,
3992                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
3993 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
3994 
3995     //=== VK_NV_device_diagnostic_checkpoints ===
3996 
3997     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
3998     void setCheckpointNV( const void *     pCheckpointMarker,
3999                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4000 
4001     //=== VK_INTEL_performance_query ===
4002 
4003     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4004     VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL(
4005       const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL * pMarkerInfo,
4006       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4007 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4008     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4009     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
4010       setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo,
4011                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4012 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4013 
4014     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4015     VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL(
4016       const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL * pMarkerInfo,
4017       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4018 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4019     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4020     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
4021       setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo,
4022                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4023 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4024 
4025     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4026     VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL(
4027       const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL * pOverrideInfo,
4028       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4029 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4030     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4031     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
4032       setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo,
4033                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
4034 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4035 
4036     //=== VK_KHR_fragment_shading_rate ===
4037 
4038     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4039     void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D *                       pFragmentSize,
4040                                     const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
4041                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4042       VULKAN_HPP_NOEXCEPT;
4043 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4044     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4045     void setFragmentShadingRateKHR( const Extent2D &                                             fragmentSize,
4046                                     const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
4047                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4048       VULKAN_HPP_NOEXCEPT;
4049 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4050 
4051     //=== VK_EXT_line_rasterization ===
4052 
4053     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4054     void setLineStippleEXT( uint32_t         lineStippleFactor,
4055                             uint16_t         lineStipplePattern,
4056                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4057 
4058     //=== VK_EXT_extended_dynamic_state ===
4059 
4060     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4061     void setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode,
4062                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4063 
4064     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4065     void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace,
4066                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4067 
4068     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4069     void
4070       setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology,
4071                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4072 
4073     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4074     void
4075       setViewportWithCountEXT( uint32_t                               viewportCount,
4076                                const VULKAN_HPP_NAMESPACE::Viewport * pViewports,
4077                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4078 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4079     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4080     void
4081       setViewportWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports,
4082                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4083 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4084 
4085     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4086     void
4087       setScissorWithCountEXT( uint32_t                             scissorCount,
4088                               const VULKAN_HPP_NAMESPACE::Rect2D * pScissors,
4089                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4090 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4091     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4092     void
4093       setScissorWithCountEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors,
4094                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4095 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4096 
4097     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4098     void bindVertexBuffers2EXT( uint32_t                                 firstBinding,
4099                                 uint32_t                                 bindingCount,
4100                                 const VULKAN_HPP_NAMESPACE::Buffer *     pBuffers,
4101                                 const VULKAN_HPP_NAMESPACE::DeviceSize * pOffsets,
4102                                 const VULKAN_HPP_NAMESPACE::DeviceSize * pSizes,
4103                                 const VULKAN_HPP_NAMESPACE::DeviceSize * pStrides,
4104                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4105 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4106     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4107     void bindVertexBuffers2EXT(
4108       uint32_t                                                   firstBinding,
4109       ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const &     buffers,
4110       ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
4111       ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
4112       ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
4113       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4114 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4115 
4116     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4117     void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable,
4118                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4119 
4120     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4121     void
4122       setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable,
4123                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4124 
4125     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4126     void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp,
4127                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4128 
4129     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4130     void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable,
4131                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4132       VULKAN_HPP_NOEXCEPT;
4133 
4134     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4135     void
4136       setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable,
4137                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4138 
4139     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4140     void setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
4141                           VULKAN_HPP_NAMESPACE::StencilOp        failOp,
4142                           VULKAN_HPP_NAMESPACE::StencilOp        passOp,
4143                           VULKAN_HPP_NAMESPACE::StencilOp        depthFailOp,
4144                           VULKAN_HPP_NAMESPACE::CompareOp        compareOp,
4145                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4146 
4147     //=== VK_NV_device_generated_commands ===
4148 
4149     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4150     void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
4151                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4152       VULKAN_HPP_NOEXCEPT;
4153 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4154     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4155     void preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV & generatedCommandsInfo,
4156                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4157       VULKAN_HPP_NOEXCEPT;
4158 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4159 
4160     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4161     void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32                          isPreprocessed,
4162                                      const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV * pGeneratedCommandsInfo,
4163                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4164       VULKAN_HPP_NOEXCEPT;
4165 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4166     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4167     void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32    isPreprocessed,
4168                                      const GeneratedCommandsInfoNV & generatedCommandsInfo,
4169                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4170       VULKAN_HPP_NOEXCEPT;
4171 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4172 
4173     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4174     void bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
4175                                     VULKAN_HPP_NAMESPACE::Pipeline          pipeline,
4176                                     uint32_t                                groupIndex,
4177                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4178       VULKAN_HPP_NOEXCEPT;
4179 
4180 #if defined( VK_ENABLE_BETA_EXTENSIONS )
4181     //=== VK_KHR_video_encode_queue ===
4182 
4183     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4184     void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR * pEncodeInfo,
4185                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4186 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4187     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4188     void encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo,
4189                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4190 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4191 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
4192 
4193     //=== VK_KHR_synchronization2 ===
4194 
4195     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4196     void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event                     event,
4197                        const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfo,
4198                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4199 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4200     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4201     void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
4202                        const DependencyInfoKHR &   dependencyInfo,
4203                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4204 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4205 
4206     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4207     void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event                  event,
4208                          VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stageMask,
4209                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4210 
4211     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4212     void waitEvents2KHR( uint32_t                                        eventCount,
4213                          const VULKAN_HPP_NAMESPACE::Event *             pEvents,
4214                          const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfos,
4215                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4216 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4217     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4218     void waitEvents2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const &             events,
4219                          ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfoKHR> const & dependencyInfos,
4220                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4221       VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
4222 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4223 
4224     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4225     void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfoKHR * pDependencyInfo,
4226                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4227 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4228     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4229     void pipelineBarrier2KHR( const DependencyInfoKHR & dependencyInfo,
4230                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4231 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4232 
4233     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4234     void writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
4235                              VULKAN_HPP_NAMESPACE::QueryPool              queryPool,
4236                              uint32_t                                     query,
4237                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4238 
4239     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4240     void writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR stage,
4241                                 VULKAN_HPP_NAMESPACE::Buffer                 dstBuffer,
4242                                 VULKAN_HPP_NAMESPACE::DeviceSize             dstOffset,
4243                                 uint32_t                                     marker,
4244                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4245 
4246     //=== VK_NV_fragment_shading_rate_enums ===
4247 
4248     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4249     void setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV                  shadingRate,
4250                                        const VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR combinerOps[2],
4251                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4252       VULKAN_HPP_NOEXCEPT;
4253 
4254     //=== VK_KHR_copy_commands2 ===
4255 
4256     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4257     void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2KHR * pCopyBufferInfo,
4258                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4259 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4260     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4261     void copyBuffer2KHR( const CopyBufferInfo2KHR & copyBufferInfo,
4262                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4263 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4264 
4265     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4266     void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2KHR * pCopyImageInfo,
4267                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4268 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4269     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4270     void copyImage2KHR( const CopyImageInfo2KHR & copyImageInfo,
4271                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4272 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4273 
4274     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4275     void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2KHR * pCopyBufferToImageInfo,
4276                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4277 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4278     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4279     void copyBufferToImage2KHR( const CopyBufferToImageInfo2KHR & copyBufferToImageInfo,
4280                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4281 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4282 
4283     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4284     void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2KHR * pCopyImageToBufferInfo,
4285                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4286 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4287     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4288     void copyImageToBuffer2KHR( const CopyImageToBufferInfo2KHR & copyImageToBufferInfo,
4289                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4290 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4291 
4292     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4293     void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2KHR * pBlitImageInfo,
4294                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4295 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4296     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4297     void blitImage2KHR( const BlitImageInfo2KHR & blitImageInfo,
4298                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4299 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4300 
4301     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4302     void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2KHR * pResolveImageInfo,
4303                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4304 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4305     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4306     void resolveImage2KHR( const ResolveImageInfo2KHR & resolveImageInfo,
4307                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4308 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4309 
4310     //=== VK_KHR_ray_tracing_pipeline ===
4311 
4312     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4313     void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
4314                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
4315                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
4316                        const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
4317                        uint32_t                                                    width,
4318                        uint32_t                                                    height,
4319                        uint32_t                                                    depth,
4320                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4321 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4322     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4323     void traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
4324                        const StridedDeviceAddressRegionKHR & missShaderBindingTable,
4325                        const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
4326                        const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
4327                        uint32_t                              width,
4328                        uint32_t                              height,
4329                        uint32_t                              depth,
4330                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4331 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4332 
4333     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4334     void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
4335                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pMissShaderBindingTable,
4336                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pHitShaderBindingTable,
4337                                const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
4338                                VULKAN_HPP_NAMESPACE::DeviceAddress                         indirectDeviceAddress,
4339                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4340 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4341     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4342     void traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
4343                                const StridedDeviceAddressRegionKHR & missShaderBindingTable,
4344                                const StridedDeviceAddressRegionKHR & hitShaderBindingTable,
4345                                const StridedDeviceAddressRegionKHR & callableShaderBindingTable,
4346                                VULKAN_HPP_NAMESPACE::DeviceAddress   indirectDeviceAddress,
4347                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4348 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4349 
4350     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4351     void setRayTracingPipelineStackSizeKHR( uint32_t         pipelineStackSize,
4352                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4353       VULKAN_HPP_NOEXCEPT;
4354 
4355     //=== VK_EXT_vertex_input_dynamic_state ===
4356 
4357     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4358     void
4359       setVertexInputEXT( uint32_t                                                        vertexBindingDescriptionCount,
4360                          const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT * pVertexBindingDescriptions,
4361                          uint32_t vertexAttributeDescriptionCount,
4362                          const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions,
4363                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4364 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4365     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4366     void setVertexInputEXT(
4367       ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const &   vertexBindingDescriptions,
4368       ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions,
4369       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4370 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4371 
4372     //=== VK_HUAWEI_subpass_shading ===
4373 
4374     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4375     void subpassShadingHUAWEI( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4376 
4377     //=== VK_EXT_extended_dynamic_state2 ===
4378 
4379     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4380     void
4381       setPatchControlPointsEXT( uint32_t         patchControlPoints,
4382                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4383 
4384     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4385     void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable,
4386                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4387       VULKAN_HPP_NOEXCEPT;
4388 
4389     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4390     void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable,
4391                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4392 
4393     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4394     void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp,
4395                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4396 
4397     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4398     void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable,
4399                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
4400       VULKAN_HPP_NOEXCEPT;
4401 
4402     //=== VK_EXT_color_write_enable ===
4403 
4404     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4405     void
4406       setColorWriteEnableEXT( uint32_t                             attachmentCount,
4407                               const VULKAN_HPP_NAMESPACE::Bool32 * pColorWriteEnables,
4408                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4409 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4410     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4411     void
4412       setColorWriteEnableEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables,
4413                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4414 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4415 
4416     //=== VK_EXT_multi_draw ===
4417 
4418     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4419     void drawMultiEXT( uint32_t                                       drawCount,
4420                        const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT * pVertexInfo,
4421                        uint32_t                                       instanceCount,
4422                        uint32_t                                       firstInstance,
4423                        uint32_t                                       stride,
4424                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4425 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4426     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4427     void drawMultiEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo,
4428                        uint32_t                                                         instanceCount,
4429                        uint32_t                                                         firstInstance,
4430                        uint32_t                                                         stride,
4431                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4432 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4433 
4434     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4435     void drawMultiIndexedEXT( uint32_t                                              drawCount,
4436                               const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT * pIndexInfo,
4437                               uint32_t                                              instanceCount,
4438                               uint32_t                                              firstInstance,
4439                               uint32_t                                              stride,
4440                               const int32_t *                                       pVertexOffset,
4441                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4442 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
4443     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
4444     void drawMultiIndexedEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo,
4445                               uint32_t                                                                instanceCount,
4446                               uint32_t                                                                firstInstance,
4447                               uint32_t                                                                stride,
4448                               Optional<const int32_t> vertexOffset VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
4449                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
4450 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
4451 
operator VkCommandBuffer() const4452     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT
4453     {
4454       return m_commandBuffer;
4455     }
4456 
operator bool() const4457     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4458     {
4459       return m_commandBuffer != VK_NULL_HANDLE;
4460     }
4461 
operator !() const4462     bool operator!() const VULKAN_HPP_NOEXCEPT
4463     {
4464       return m_commandBuffer == VK_NULL_HANDLE;
4465     }
4466 
4467   private:
4468     VkCommandBuffer m_commandBuffer = {};
4469   };
4470   static_assert( sizeof( VULKAN_HPP_NAMESPACE::CommandBuffer ) == sizeof( VkCommandBuffer ),
4471                  "handle and wrapper have different size!" );
4472 
4473   template <>
4474   struct VULKAN_HPP_DEPRECATED(
4475     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eCommandBuffer>
4476   {
4477     using type = VULKAN_HPP_NAMESPACE::CommandBuffer;
4478   };
4479 
4480   template <>
4481   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer>
4482   {
4483     using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
4484   };
4485 
4486   template <>
4487   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
4488                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer>
4489   {
4490     using Type = VULKAN_HPP_NAMESPACE::CommandBuffer;
4491   };
4492 
4493   template <>
4494   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandBuffer>
4495   {
4496     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4497   };
4498 
4499   class DeviceMemory
4500   {
4501   public:
4502     using CType = VkDeviceMemory;
4503 
4504     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
4505       VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory;
4506     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4507       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory;
4508 
4509   public:
4510     VULKAN_HPP_CONSTEXPR         DeviceMemory() = default;
DeviceMemory(std::nullptr_t)4511     VULKAN_HPP_CONSTEXPR         DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DeviceMemory(VkDeviceMemory deviceMemory)4512     VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT
4513       : m_deviceMemory( deviceMemory )
4514     {}
4515 
4516 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDeviceMemory deviceMemory)4517     DeviceMemory & operator=( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT
4518     {
4519       m_deviceMemory = deviceMemory;
4520       return *this;
4521     }
4522 #endif
4523 
operator =(std::nullptr_t)4524     DeviceMemory & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4525     {
4526       m_deviceMemory = {};
4527       return *this;
4528     }
4529 
4530 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4531     auto operator<=>( DeviceMemory const & ) const = default;
4532 #else
operator ==(DeviceMemory const & rhs) const4533     bool operator==( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
4534     {
4535       return m_deviceMemory == rhs.m_deviceMemory;
4536     }
4537 
operator !=(DeviceMemory const & rhs) const4538     bool operator!=( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
4539     {
4540       return m_deviceMemory != rhs.m_deviceMemory;
4541     }
4542 
operator <(DeviceMemory const & rhs) const4543     bool operator<( DeviceMemory const & rhs ) const VULKAN_HPP_NOEXCEPT
4544     {
4545       return m_deviceMemory < rhs.m_deviceMemory;
4546     }
4547 #endif
4548 
operator VkDeviceMemory() const4549     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const VULKAN_HPP_NOEXCEPT
4550     {
4551       return m_deviceMemory;
4552     }
4553 
operator bool() const4554     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4555     {
4556       return m_deviceMemory != VK_NULL_HANDLE;
4557     }
4558 
operator !() const4559     bool operator!() const VULKAN_HPP_NOEXCEPT
4560     {
4561       return m_deviceMemory == VK_NULL_HANDLE;
4562     }
4563 
4564   private:
4565     VkDeviceMemory m_deviceMemory = {};
4566   };
4567   static_assert( sizeof( VULKAN_HPP_NAMESPACE::DeviceMemory ) == sizeof( VkDeviceMemory ),
4568                  "handle and wrapper have different size!" );
4569 
4570   template <>
4571   struct VULKAN_HPP_DEPRECATED(
4572     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDeviceMemory>
4573   {
4574     using type = VULKAN_HPP_NAMESPACE::DeviceMemory;
4575   };
4576 
4577   template <>
4578   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory>
4579   {
4580     using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
4581   };
4582 
4583   template <>
4584   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
4585                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory>
4586   {
4587     using Type = VULKAN_HPP_NAMESPACE::DeviceMemory;
4588   };
4589 
4590   template <>
4591   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeviceMemory>
4592   {
4593     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4594   };
4595 
4596 #if defined( VK_ENABLE_BETA_EXTENSIONS )
4597   class VideoSessionKHR
4598   {
4599   public:
4600     using CType = VkVideoSessionKHR;
4601 
4602     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
4603       VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR;
4604     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4605       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
4606 
4607   public:
4608     VULKAN_HPP_CONSTEXPR         VideoSessionKHR() = default;
VideoSessionKHR(std::nullptr_t)4609     VULKAN_HPP_CONSTEXPR         VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
VideoSessionKHR(VkVideoSessionKHR videoSessionKHR)4610     VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT
4611       : m_videoSessionKHR( videoSessionKHR )
4612     {}
4613 
4614 #  if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkVideoSessionKHR videoSessionKHR)4615     VideoSessionKHR & operator=( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT
4616     {
4617       m_videoSessionKHR = videoSessionKHR;
4618       return *this;
4619     }
4620 #  endif
4621 
operator =(std::nullptr_t)4622     VideoSessionKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4623     {
4624       m_videoSessionKHR = {};
4625       return *this;
4626     }
4627 
4628 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4629     auto operator<=>( VideoSessionKHR const & ) const = default;
4630 #  else
operator ==(VideoSessionKHR const & rhs) const4631     bool operator==( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4632     {
4633       return m_videoSessionKHR == rhs.m_videoSessionKHR;
4634     }
4635 
operator !=(VideoSessionKHR const & rhs) const4636     bool operator!=( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4637     {
4638       return m_videoSessionKHR != rhs.m_videoSessionKHR;
4639     }
4640 
operator <(VideoSessionKHR const & rhs) const4641     bool operator<( VideoSessionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4642     {
4643       return m_videoSessionKHR < rhs.m_videoSessionKHR;
4644     }
4645 #  endif
4646 
operator VkVideoSessionKHR() const4647     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionKHR() const VULKAN_HPP_NOEXCEPT
4648     {
4649       return m_videoSessionKHR;
4650     }
4651 
operator bool() const4652     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4653     {
4654       return m_videoSessionKHR != VK_NULL_HANDLE;
4655     }
4656 
operator !() const4657     bool operator!() const VULKAN_HPP_NOEXCEPT
4658     {
4659       return m_videoSessionKHR == VK_NULL_HANDLE;
4660     }
4661 
4662   private:
4663     VkVideoSessionKHR m_videoSessionKHR = {};
4664   };
4665   static_assert( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionKHR ) == sizeof( VkVideoSessionKHR ),
4666                  "handle and wrapper have different size!" );
4667 
4668   template <>
4669   struct VULKAN_HPP_DEPRECATED(
4670     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eVideoSessionKHR>
4671   {
4672     using type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;
4673   };
4674 
4675   template <>
4676   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR>
4677   {
4678     using Type = VULKAN_HPP_NAMESPACE::VideoSessionKHR;
4679   };
4680 
4681   template <>
4682   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>
4683   {
4684     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4685   };
4686 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
4687 
4688   class DeferredOperationKHR
4689   {
4690   public:
4691     using CType = VkDeferredOperationKHR;
4692 
4693     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
4694       VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR;
4695     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4696       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
4697 
4698   public:
4699     VULKAN_HPP_CONSTEXPR         DeferredOperationKHR() = default;
DeferredOperationKHR(std::nullptr_t)4700     VULKAN_HPP_CONSTEXPR         DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DeferredOperationKHR(VkDeferredOperationKHR deferredOperationKHR)4701     VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
4702       : m_deferredOperationKHR( deferredOperationKHR )
4703     {}
4704 
4705 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDeferredOperationKHR deferredOperationKHR)4706     DeferredOperationKHR & operator=( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT
4707     {
4708       m_deferredOperationKHR = deferredOperationKHR;
4709       return *this;
4710     }
4711 #endif
4712 
operator =(std::nullptr_t)4713     DeferredOperationKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4714     {
4715       m_deferredOperationKHR = {};
4716       return *this;
4717     }
4718 
4719 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4720     auto operator<=>( DeferredOperationKHR const & ) const = default;
4721 #else
operator ==(DeferredOperationKHR const & rhs) const4722     bool operator==( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4723     {
4724       return m_deferredOperationKHR == rhs.m_deferredOperationKHR;
4725     }
4726 
operator !=(DeferredOperationKHR const & rhs) const4727     bool operator!=( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4728     {
4729       return m_deferredOperationKHR != rhs.m_deferredOperationKHR;
4730     }
4731 
operator <(DeferredOperationKHR const & rhs) const4732     bool operator<( DeferredOperationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
4733     {
4734       return m_deferredOperationKHR < rhs.m_deferredOperationKHR;
4735     }
4736 #endif
4737 
operator VkDeferredOperationKHR() const4738     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeferredOperationKHR() const VULKAN_HPP_NOEXCEPT
4739     {
4740       return m_deferredOperationKHR;
4741     }
4742 
operator bool() const4743     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4744     {
4745       return m_deferredOperationKHR != VK_NULL_HANDLE;
4746     }
4747 
operator !() const4748     bool operator!() const VULKAN_HPP_NOEXCEPT
4749     {
4750       return m_deferredOperationKHR == VK_NULL_HANDLE;
4751     }
4752 
4753   private:
4754     VkDeferredOperationKHR m_deferredOperationKHR = {};
4755   };
4756   static_assert( sizeof( VULKAN_HPP_NAMESPACE::DeferredOperationKHR ) == sizeof( VkDeferredOperationKHR ),
4757                  "handle and wrapper have different size!" );
4758 
4759   template <>
4760   struct VULKAN_HPP_DEPRECATED(
4761     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDeferredOperationKHR>
4762   {
4763     using type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR;
4764   };
4765 
4766   template <>
4767   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR>
4768   {
4769     using Type = VULKAN_HPP_NAMESPACE::DeferredOperationKHR;
4770   };
4771 
4772   template <>
4773   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>
4774   {
4775     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4776   };
4777 
4778   class BufferView
4779   {
4780   public:
4781     using CType = VkBufferView;
4782 
4783     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
4784       VULKAN_HPP_NAMESPACE::ObjectType::eBufferView;
4785     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4786       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView;
4787 
4788   public:
4789     VULKAN_HPP_CONSTEXPR         BufferView() = default;
BufferView(std::nullptr_t)4790     VULKAN_HPP_CONSTEXPR         BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
BufferView(VkBufferView bufferView)4791     VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT : m_bufferView( bufferView )
4792     {}
4793 
4794 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkBufferView bufferView)4795     BufferView & operator=( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT
4796     {
4797       m_bufferView = bufferView;
4798       return *this;
4799     }
4800 #endif
4801 
operator =(std::nullptr_t)4802     BufferView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4803     {
4804       m_bufferView = {};
4805       return *this;
4806     }
4807 
4808 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4809     auto operator<=>( BufferView const & ) const = default;
4810 #else
operator ==(BufferView const & rhs) const4811     bool operator==( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
4812     {
4813       return m_bufferView == rhs.m_bufferView;
4814     }
4815 
operator !=(BufferView const & rhs) const4816     bool operator!=( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
4817     {
4818       return m_bufferView != rhs.m_bufferView;
4819     }
4820 
operator <(BufferView const & rhs) const4821     bool operator<( BufferView const & rhs ) const VULKAN_HPP_NOEXCEPT
4822     {
4823       return m_bufferView < rhs.m_bufferView;
4824     }
4825 #endif
4826 
operator VkBufferView() const4827     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const VULKAN_HPP_NOEXCEPT
4828     {
4829       return m_bufferView;
4830     }
4831 
operator bool() const4832     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4833     {
4834       return m_bufferView != VK_NULL_HANDLE;
4835     }
4836 
operator !() const4837     bool operator!() const VULKAN_HPP_NOEXCEPT
4838     {
4839       return m_bufferView == VK_NULL_HANDLE;
4840     }
4841 
4842   private:
4843     VkBufferView m_bufferView = {};
4844   };
4845   static_assert( sizeof( VULKAN_HPP_NAMESPACE::BufferView ) == sizeof( VkBufferView ),
4846                  "handle and wrapper have different size!" );
4847 
4848   template <>
4849   struct VULKAN_HPP_DEPRECATED(
4850     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eBufferView>
4851   {
4852     using type = VULKAN_HPP_NAMESPACE::BufferView;
4853   };
4854 
4855   template <>
4856   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eBufferView>
4857   {
4858     using Type = VULKAN_HPP_NAMESPACE::BufferView;
4859   };
4860 
4861   template <>
4862   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
4863                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView>
4864   {
4865     using Type = VULKAN_HPP_NAMESPACE::BufferView;
4866   };
4867 
4868   template <>
4869   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::BufferView>
4870   {
4871     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4872   };
4873 
4874   class CommandPool
4875   {
4876   public:
4877     using CType = VkCommandPool;
4878 
4879     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
4880       VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool;
4881     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4882       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool;
4883 
4884   public:
4885     VULKAN_HPP_CONSTEXPR         CommandPool() = default;
CommandPool(std::nullptr_t)4886     VULKAN_HPP_CONSTEXPR         CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
CommandPool(VkCommandPool commandPool)4887     VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT
4888       : m_commandPool( commandPool )
4889     {}
4890 
4891 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkCommandPool commandPool)4892     CommandPool & operator=( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT
4893     {
4894       m_commandPool = commandPool;
4895       return *this;
4896     }
4897 #endif
4898 
operator =(std::nullptr_t)4899     CommandPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4900     {
4901       m_commandPool = {};
4902       return *this;
4903     }
4904 
4905 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
4906     auto operator<=>( CommandPool const & ) const = default;
4907 #else
operator ==(CommandPool const & rhs) const4908     bool operator==( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
4909     {
4910       return m_commandPool == rhs.m_commandPool;
4911     }
4912 
operator !=(CommandPool const & rhs) const4913     bool operator!=( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
4914     {
4915       return m_commandPool != rhs.m_commandPool;
4916     }
4917 
operator <(CommandPool const & rhs) const4918     bool operator<( CommandPool const & rhs ) const VULKAN_HPP_NOEXCEPT
4919     {
4920       return m_commandPool < rhs.m_commandPool;
4921     }
4922 #endif
4923 
operator VkCommandPool() const4924     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const VULKAN_HPP_NOEXCEPT
4925     {
4926       return m_commandPool;
4927     }
4928 
operator bool() const4929     explicit operator bool() const VULKAN_HPP_NOEXCEPT
4930     {
4931       return m_commandPool != VK_NULL_HANDLE;
4932     }
4933 
operator !() const4934     bool operator!() const VULKAN_HPP_NOEXCEPT
4935     {
4936       return m_commandPool == VK_NULL_HANDLE;
4937     }
4938 
4939   private:
4940     VkCommandPool m_commandPool = {};
4941   };
4942   static_assert( sizeof( VULKAN_HPP_NAMESPACE::CommandPool ) == sizeof( VkCommandPool ),
4943                  "handle and wrapper have different size!" );
4944 
4945   template <>
4946   struct VULKAN_HPP_DEPRECATED(
4947     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eCommandPool>
4948   {
4949     using type = VULKAN_HPP_NAMESPACE::CommandPool;
4950   };
4951 
4952   template <>
4953   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool>
4954   {
4955     using Type = VULKAN_HPP_NAMESPACE::CommandPool;
4956   };
4957 
4958   template <>
4959   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
4960                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool>
4961   {
4962     using Type = VULKAN_HPP_NAMESPACE::CommandPool;
4963   };
4964 
4965   template <>
4966   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CommandPool>
4967   {
4968     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
4969   };
4970 
4971   class PipelineCache
4972   {
4973   public:
4974     using CType = VkPipelineCache;
4975 
4976     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
4977       VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache;
4978     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
4979       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache;
4980 
4981   public:
4982     VULKAN_HPP_CONSTEXPR         PipelineCache() = default;
PipelineCache(std::nullptr_t)4983     VULKAN_HPP_CONSTEXPR         PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
PipelineCache(VkPipelineCache pipelineCache)4984     VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT
4985       : m_pipelineCache( pipelineCache )
4986     {}
4987 
4988 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkPipelineCache pipelineCache)4989     PipelineCache & operator=( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT
4990     {
4991       m_pipelineCache = pipelineCache;
4992       return *this;
4993     }
4994 #endif
4995 
operator =(std::nullptr_t)4996     PipelineCache & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
4997     {
4998       m_pipelineCache = {};
4999       return *this;
5000     }
5001 
5002 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5003     auto operator<=>( PipelineCache const & ) const = default;
5004 #else
operator ==(PipelineCache const & rhs) const5005     bool operator==( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
5006     {
5007       return m_pipelineCache == rhs.m_pipelineCache;
5008     }
5009 
operator !=(PipelineCache const & rhs) const5010     bool operator!=( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
5011     {
5012       return m_pipelineCache != rhs.m_pipelineCache;
5013     }
5014 
operator <(PipelineCache const & rhs) const5015     bool operator<( PipelineCache const & rhs ) const VULKAN_HPP_NOEXCEPT
5016     {
5017       return m_pipelineCache < rhs.m_pipelineCache;
5018     }
5019 #endif
5020 
operator VkPipelineCache() const5021     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const VULKAN_HPP_NOEXCEPT
5022     {
5023       return m_pipelineCache;
5024     }
5025 
operator bool() const5026     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5027     {
5028       return m_pipelineCache != VK_NULL_HANDLE;
5029     }
5030 
operator !() const5031     bool operator!() const VULKAN_HPP_NOEXCEPT
5032     {
5033       return m_pipelineCache == VK_NULL_HANDLE;
5034     }
5035 
5036   private:
5037     VkPipelineCache m_pipelineCache = {};
5038   };
5039   static_assert( sizeof( VULKAN_HPP_NAMESPACE::PipelineCache ) == sizeof( VkPipelineCache ),
5040                  "handle and wrapper have different size!" );
5041 
5042   template <>
5043   struct VULKAN_HPP_DEPRECATED(
5044     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePipelineCache>
5045   {
5046     using type = VULKAN_HPP_NAMESPACE::PipelineCache;
5047   };
5048 
5049   template <>
5050   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache>
5051   {
5052     using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
5053   };
5054 
5055   template <>
5056   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5057                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache>
5058   {
5059     using Type = VULKAN_HPP_NAMESPACE::PipelineCache;
5060   };
5061 
5062   template <>
5063   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PipelineCache>
5064   {
5065     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5066   };
5067 
5068   class CuFunctionNVX
5069   {
5070   public:
5071     using CType = VkCuFunctionNVX;
5072 
5073     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5074       VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX;
5075     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5076       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX;
5077 
5078   public:
5079     VULKAN_HPP_CONSTEXPR         CuFunctionNVX() = default;
CuFunctionNVX(std::nullptr_t)5080     VULKAN_HPP_CONSTEXPR         CuFunctionNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
CuFunctionNVX(VkCuFunctionNVX cuFunctionNVX)5081     VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT
5082       : m_cuFunctionNVX( cuFunctionNVX )
5083     {}
5084 
5085 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkCuFunctionNVX cuFunctionNVX)5086     CuFunctionNVX & operator=( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT
5087     {
5088       m_cuFunctionNVX = cuFunctionNVX;
5089       return *this;
5090     }
5091 #endif
5092 
operator =(std::nullptr_t)5093     CuFunctionNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5094     {
5095       m_cuFunctionNVX = {};
5096       return *this;
5097     }
5098 
5099 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5100     auto operator<=>( CuFunctionNVX const & ) const = default;
5101 #else
operator ==(CuFunctionNVX const & rhs) const5102     bool operator==( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5103     {
5104       return m_cuFunctionNVX == rhs.m_cuFunctionNVX;
5105     }
5106 
operator !=(CuFunctionNVX const & rhs) const5107     bool operator!=( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5108     {
5109       return m_cuFunctionNVX != rhs.m_cuFunctionNVX;
5110     }
5111 
operator <(CuFunctionNVX const & rhs) const5112     bool operator<( CuFunctionNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5113     {
5114       return m_cuFunctionNVX < rhs.m_cuFunctionNVX;
5115     }
5116 #endif
5117 
operator VkCuFunctionNVX() const5118     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuFunctionNVX() const VULKAN_HPP_NOEXCEPT
5119     {
5120       return m_cuFunctionNVX;
5121     }
5122 
operator bool() const5123     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5124     {
5125       return m_cuFunctionNVX != VK_NULL_HANDLE;
5126     }
5127 
operator !() const5128     bool operator!() const VULKAN_HPP_NOEXCEPT
5129     {
5130       return m_cuFunctionNVX == VK_NULL_HANDLE;
5131     }
5132 
5133   private:
5134     VkCuFunctionNVX m_cuFunctionNVX = {};
5135   };
5136   static_assert( sizeof( VULKAN_HPP_NAMESPACE::CuFunctionNVX ) == sizeof( VkCuFunctionNVX ),
5137                  "handle and wrapper have different size!" );
5138 
5139   template <>
5140   struct VULKAN_HPP_DEPRECATED(
5141     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eCuFunctionNVX>
5142   {
5143     using type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
5144   };
5145 
5146   template <>
5147   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX>
5148   {
5149     using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
5150   };
5151 
5152   template <>
5153   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5154                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX>
5155   {
5156     using Type = VULKAN_HPP_NAMESPACE::CuFunctionNVX;
5157   };
5158 
5159   template <>
5160   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>
5161   {
5162     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5163   };
5164 
5165   class CuModuleNVX
5166   {
5167   public:
5168     using CType = VkCuModuleNVX;
5169 
5170     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5171       VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX;
5172     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5173       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX;
5174 
5175   public:
5176     VULKAN_HPP_CONSTEXPR         CuModuleNVX() = default;
CuModuleNVX(std::nullptr_t)5177     VULKAN_HPP_CONSTEXPR         CuModuleNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
CuModuleNVX(VkCuModuleNVX cuModuleNVX)5178     VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT
5179       : m_cuModuleNVX( cuModuleNVX )
5180     {}
5181 
5182 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkCuModuleNVX cuModuleNVX)5183     CuModuleNVX & operator=( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT
5184     {
5185       m_cuModuleNVX = cuModuleNVX;
5186       return *this;
5187     }
5188 #endif
5189 
operator =(std::nullptr_t)5190     CuModuleNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5191     {
5192       m_cuModuleNVX = {};
5193       return *this;
5194     }
5195 
5196 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5197     auto operator<=>( CuModuleNVX const & ) const = default;
5198 #else
operator ==(CuModuleNVX const & rhs) const5199     bool operator==( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5200     {
5201       return m_cuModuleNVX == rhs.m_cuModuleNVX;
5202     }
5203 
operator !=(CuModuleNVX const & rhs) const5204     bool operator!=( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5205     {
5206       return m_cuModuleNVX != rhs.m_cuModuleNVX;
5207     }
5208 
operator <(CuModuleNVX const & rhs) const5209     bool operator<( CuModuleNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
5210     {
5211       return m_cuModuleNVX < rhs.m_cuModuleNVX;
5212     }
5213 #endif
5214 
operator VkCuModuleNVX() const5215     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuModuleNVX() const VULKAN_HPP_NOEXCEPT
5216     {
5217       return m_cuModuleNVX;
5218     }
5219 
operator bool() const5220     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5221     {
5222       return m_cuModuleNVX != VK_NULL_HANDLE;
5223     }
5224 
operator !() const5225     bool operator!() const VULKAN_HPP_NOEXCEPT
5226     {
5227       return m_cuModuleNVX == VK_NULL_HANDLE;
5228     }
5229 
5230   private:
5231     VkCuModuleNVX m_cuModuleNVX = {};
5232   };
5233   static_assert( sizeof( VULKAN_HPP_NAMESPACE::CuModuleNVX ) == sizeof( VkCuModuleNVX ),
5234                  "handle and wrapper have different size!" );
5235 
5236   template <>
5237   struct VULKAN_HPP_DEPRECATED(
5238     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eCuModuleNVX>
5239   {
5240     using type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
5241   };
5242 
5243   template <>
5244   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX>
5245   {
5246     using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
5247   };
5248 
5249   template <>
5250   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5251                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX>
5252   {
5253     using Type = VULKAN_HPP_NAMESPACE::CuModuleNVX;
5254   };
5255 
5256   template <>
5257   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::CuModuleNVX>
5258   {
5259     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5260   };
5261 
5262   class DescriptorPool
5263   {
5264   public:
5265     using CType = VkDescriptorPool;
5266 
5267     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5268       VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool;
5269     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5270       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool;
5271 
5272   public:
5273     VULKAN_HPP_CONSTEXPR         DescriptorPool() = default;
DescriptorPool(std::nullptr_t)5274     VULKAN_HPP_CONSTEXPR         DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DescriptorPool(VkDescriptorPool descriptorPool)5275     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT
5276       : m_descriptorPool( descriptorPool )
5277     {}
5278 
5279 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDescriptorPool descriptorPool)5280     DescriptorPool & operator=( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT
5281     {
5282       m_descriptorPool = descriptorPool;
5283       return *this;
5284     }
5285 #endif
5286 
operator =(std::nullptr_t)5287     DescriptorPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5288     {
5289       m_descriptorPool = {};
5290       return *this;
5291     }
5292 
5293 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5294     auto operator<=>( DescriptorPool const & ) const = default;
5295 #else
operator ==(DescriptorPool const & rhs) const5296     bool operator==( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5297     {
5298       return m_descriptorPool == rhs.m_descriptorPool;
5299     }
5300 
operator !=(DescriptorPool const & rhs) const5301     bool operator!=( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5302     {
5303       return m_descriptorPool != rhs.m_descriptorPool;
5304     }
5305 
operator <(DescriptorPool const & rhs) const5306     bool operator<( DescriptorPool const & rhs ) const VULKAN_HPP_NOEXCEPT
5307     {
5308       return m_descriptorPool < rhs.m_descriptorPool;
5309     }
5310 #endif
5311 
operator VkDescriptorPool() const5312     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const VULKAN_HPP_NOEXCEPT
5313     {
5314       return m_descriptorPool;
5315     }
5316 
operator bool() const5317     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5318     {
5319       return m_descriptorPool != VK_NULL_HANDLE;
5320     }
5321 
operator !() const5322     bool operator!() const VULKAN_HPP_NOEXCEPT
5323     {
5324       return m_descriptorPool == VK_NULL_HANDLE;
5325     }
5326 
5327   private:
5328     VkDescriptorPool m_descriptorPool = {};
5329   };
5330   static_assert( sizeof( VULKAN_HPP_NAMESPACE::DescriptorPool ) == sizeof( VkDescriptorPool ),
5331                  "handle and wrapper have different size!" );
5332 
5333   template <>
5334   struct VULKAN_HPP_DEPRECATED(
5335     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDescriptorPool>
5336   {
5337     using type = VULKAN_HPP_NAMESPACE::DescriptorPool;
5338   };
5339 
5340   template <>
5341   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool>
5342   {
5343     using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
5344   };
5345 
5346   template <>
5347   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5348                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool>
5349   {
5350     using Type = VULKAN_HPP_NAMESPACE::DescriptorPool;
5351   };
5352 
5353   template <>
5354   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorPool>
5355   {
5356     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5357   };
5358 
5359   class DescriptorSetLayout
5360   {
5361   public:
5362     using CType = VkDescriptorSetLayout;
5363 
5364     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5365       VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout;
5366     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5367       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout;
5368 
5369   public:
5370     VULKAN_HPP_CONSTEXPR         DescriptorSetLayout() = default;
DescriptorSetLayout(std::nullptr_t)5371     VULKAN_HPP_CONSTEXPR         DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout)5372     VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
5373       : m_descriptorSetLayout( descriptorSetLayout )
5374     {}
5375 
5376 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDescriptorSetLayout descriptorSetLayout)5377     DescriptorSetLayout & operator=( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT
5378     {
5379       m_descriptorSetLayout = descriptorSetLayout;
5380       return *this;
5381     }
5382 #endif
5383 
operator =(std::nullptr_t)5384     DescriptorSetLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5385     {
5386       m_descriptorSetLayout = {};
5387       return *this;
5388     }
5389 
5390 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5391     auto operator<=>( DescriptorSetLayout const & ) const = default;
5392 #else
operator ==(DescriptorSetLayout const & rhs) const5393     bool operator==( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
5394     {
5395       return m_descriptorSetLayout == rhs.m_descriptorSetLayout;
5396     }
5397 
operator !=(DescriptorSetLayout const & rhs) const5398     bool operator!=( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
5399     {
5400       return m_descriptorSetLayout != rhs.m_descriptorSetLayout;
5401     }
5402 
operator <(DescriptorSetLayout const & rhs) const5403     bool operator<( DescriptorSetLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
5404     {
5405       return m_descriptorSetLayout < rhs.m_descriptorSetLayout;
5406     }
5407 #endif
5408 
operator VkDescriptorSetLayout() const5409     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const VULKAN_HPP_NOEXCEPT
5410     {
5411       return m_descriptorSetLayout;
5412     }
5413 
operator bool() const5414     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5415     {
5416       return m_descriptorSetLayout != VK_NULL_HANDLE;
5417     }
5418 
operator !() const5419     bool operator!() const VULKAN_HPP_NOEXCEPT
5420     {
5421       return m_descriptorSetLayout == VK_NULL_HANDLE;
5422     }
5423 
5424   private:
5425     VkDescriptorSetLayout m_descriptorSetLayout = {};
5426   };
5427   static_assert( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ),
5428                  "handle and wrapper have different size!" );
5429 
5430   template <>
5431   struct VULKAN_HPP_DEPRECATED(
5432     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDescriptorSetLayout>
5433   {
5434     using type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
5435   };
5436 
5437   template <>
5438   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout>
5439   {
5440     using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
5441   };
5442 
5443   template <>
5444   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5445                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout>
5446   {
5447     using Type = VULKAN_HPP_NAMESPACE::DescriptorSetLayout;
5448   };
5449 
5450   template <>
5451   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>
5452   {
5453     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5454   };
5455 
5456   class Framebuffer
5457   {
5458   public:
5459     using CType = VkFramebuffer;
5460 
5461     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5462       VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer;
5463     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5464       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer;
5465 
5466   public:
5467     VULKAN_HPP_CONSTEXPR         Framebuffer() = default;
Framebuffer(std::nullptr_t)5468     VULKAN_HPP_CONSTEXPR         Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Framebuffer(VkFramebuffer framebuffer)5469     VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT
5470       : m_framebuffer( framebuffer )
5471     {}
5472 
5473 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkFramebuffer framebuffer)5474     Framebuffer & operator=( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT
5475     {
5476       m_framebuffer = framebuffer;
5477       return *this;
5478     }
5479 #endif
5480 
operator =(std::nullptr_t)5481     Framebuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5482     {
5483       m_framebuffer = {};
5484       return *this;
5485     }
5486 
5487 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5488     auto operator<=>( Framebuffer const & ) const = default;
5489 #else
operator ==(Framebuffer const & rhs) const5490     bool operator==( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
5491     {
5492       return m_framebuffer == rhs.m_framebuffer;
5493     }
5494 
operator !=(Framebuffer const & rhs) const5495     bool operator!=( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
5496     {
5497       return m_framebuffer != rhs.m_framebuffer;
5498     }
5499 
operator <(Framebuffer const & rhs) const5500     bool operator<( Framebuffer const & rhs ) const VULKAN_HPP_NOEXCEPT
5501     {
5502       return m_framebuffer < rhs.m_framebuffer;
5503     }
5504 #endif
5505 
operator VkFramebuffer() const5506     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const VULKAN_HPP_NOEXCEPT
5507     {
5508       return m_framebuffer;
5509     }
5510 
operator bool() const5511     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5512     {
5513       return m_framebuffer != VK_NULL_HANDLE;
5514     }
5515 
operator !() const5516     bool operator!() const VULKAN_HPP_NOEXCEPT
5517     {
5518       return m_framebuffer == VK_NULL_HANDLE;
5519     }
5520 
5521   private:
5522     VkFramebuffer m_framebuffer = {};
5523   };
5524   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Framebuffer ) == sizeof( VkFramebuffer ),
5525                  "handle and wrapper have different size!" );
5526 
5527   template <>
5528   struct VULKAN_HPP_DEPRECATED(
5529     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eFramebuffer>
5530   {
5531     using type = VULKAN_HPP_NAMESPACE::Framebuffer;
5532   };
5533 
5534   template <>
5535   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer>
5536   {
5537     using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
5538   };
5539 
5540   template <>
5541   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5542                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer>
5543   {
5544     using Type = VULKAN_HPP_NAMESPACE::Framebuffer;
5545   };
5546 
5547   template <>
5548   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Framebuffer>
5549   {
5550     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5551   };
5552 
5553   class IndirectCommandsLayoutNV
5554   {
5555   public:
5556     using CType = VkIndirectCommandsLayoutNV;
5557 
5558     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5559       VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV;
5560     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5561       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
5562 
5563   public:
5564     VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV() = default;
IndirectCommandsLayoutNV(std::nullptr_t)5565     VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
5566     VULKAN_HPP_TYPESAFE_EXPLICIT
IndirectCommandsLayoutNV(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV)5567       IndirectCommandsLayoutNV( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
5568       : m_indirectCommandsLayoutNV( indirectCommandsLayoutNV )
5569     {}
5570 
5571 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkIndirectCommandsLayoutNV indirectCommandsLayoutNV)5572     IndirectCommandsLayoutNV & operator=( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT
5573     {
5574       m_indirectCommandsLayoutNV = indirectCommandsLayoutNV;
5575       return *this;
5576     }
5577 #endif
5578 
operator =(std::nullptr_t)5579     IndirectCommandsLayoutNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5580     {
5581       m_indirectCommandsLayoutNV = {};
5582       return *this;
5583     }
5584 
5585 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5586     auto operator<=>( IndirectCommandsLayoutNV const & ) const = default;
5587 #else
operator ==(IndirectCommandsLayoutNV const & rhs) const5588     bool operator==( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
5589     {
5590       return m_indirectCommandsLayoutNV == rhs.m_indirectCommandsLayoutNV;
5591     }
5592 
operator !=(IndirectCommandsLayoutNV const & rhs) const5593     bool operator!=( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
5594     {
5595       return m_indirectCommandsLayoutNV != rhs.m_indirectCommandsLayoutNV;
5596     }
5597 
operator <(IndirectCommandsLayoutNV const & rhs) const5598     bool operator<( IndirectCommandsLayoutNV const & rhs ) const VULKAN_HPP_NOEXCEPT
5599     {
5600       return m_indirectCommandsLayoutNV < rhs.m_indirectCommandsLayoutNV;
5601     }
5602 #endif
5603 
operator VkIndirectCommandsLayoutNV() const5604     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT
5605     {
5606       return m_indirectCommandsLayoutNV;
5607     }
5608 
operator bool() const5609     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5610     {
5611       return m_indirectCommandsLayoutNV != VK_NULL_HANDLE;
5612     }
5613 
operator !() const5614     bool operator!() const VULKAN_HPP_NOEXCEPT
5615     {
5616       return m_indirectCommandsLayoutNV == VK_NULL_HANDLE;
5617     }
5618 
5619   private:
5620     VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {};
5621   };
5622   static_assert( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV ) == sizeof( VkIndirectCommandsLayoutNV ),
5623                  "handle and wrapper have different size!" );
5624 
5625   template <>
5626   struct VULKAN_HPP_DEPRECATED(
5627     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eIndirectCommandsLayoutNV>
5628   {
5629     using type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;
5630   };
5631 
5632   template <>
5633   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV>
5634   {
5635     using Type = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV;
5636   };
5637 
5638   template <>
5639   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>
5640   {
5641     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5642   };
5643 
5644   class PrivateDataSlotEXT
5645   {
5646   public:
5647     using CType = VkPrivateDataSlotEXT;
5648 
5649     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5650       VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlotEXT;
5651     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5652       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
5653 
5654   public:
5655     VULKAN_HPP_CONSTEXPR         PrivateDataSlotEXT() = default;
PrivateDataSlotEXT(std::nullptr_t)5656     VULKAN_HPP_CONSTEXPR         PrivateDataSlotEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
PrivateDataSlotEXT(VkPrivateDataSlotEXT privateDataSlotEXT)5657     VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlotEXT( VkPrivateDataSlotEXT privateDataSlotEXT ) VULKAN_HPP_NOEXCEPT
5658       : m_privateDataSlotEXT( privateDataSlotEXT )
5659     {}
5660 
5661 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkPrivateDataSlotEXT privateDataSlotEXT)5662     PrivateDataSlotEXT & operator=( VkPrivateDataSlotEXT privateDataSlotEXT ) VULKAN_HPP_NOEXCEPT
5663     {
5664       m_privateDataSlotEXT = privateDataSlotEXT;
5665       return *this;
5666     }
5667 #endif
5668 
operator =(std::nullptr_t)5669     PrivateDataSlotEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5670     {
5671       m_privateDataSlotEXT = {};
5672       return *this;
5673     }
5674 
5675 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5676     auto operator<=>( PrivateDataSlotEXT const & ) const = default;
5677 #else
operator ==(PrivateDataSlotEXT const & rhs) const5678     bool operator==( PrivateDataSlotEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
5679     {
5680       return m_privateDataSlotEXT == rhs.m_privateDataSlotEXT;
5681     }
5682 
operator !=(PrivateDataSlotEXT const & rhs) const5683     bool operator!=( PrivateDataSlotEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
5684     {
5685       return m_privateDataSlotEXT != rhs.m_privateDataSlotEXT;
5686     }
5687 
operator <(PrivateDataSlotEXT const & rhs) const5688     bool operator<( PrivateDataSlotEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
5689     {
5690       return m_privateDataSlotEXT < rhs.m_privateDataSlotEXT;
5691     }
5692 #endif
5693 
operator VkPrivateDataSlotEXT() const5694     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPrivateDataSlotEXT() const VULKAN_HPP_NOEXCEPT
5695     {
5696       return m_privateDataSlotEXT;
5697     }
5698 
operator bool() const5699     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5700     {
5701       return m_privateDataSlotEXT != VK_NULL_HANDLE;
5702     }
5703 
operator !() const5704     bool operator!() const VULKAN_HPP_NOEXCEPT
5705     {
5706       return m_privateDataSlotEXT == VK_NULL_HANDLE;
5707     }
5708 
5709   private:
5710     VkPrivateDataSlotEXT m_privateDataSlotEXT = {};
5711   };
5712   static_assert( sizeof( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT ) == sizeof( VkPrivateDataSlotEXT ),
5713                  "handle and wrapper have different size!" );
5714 
5715   template <>
5716   struct VULKAN_HPP_DEPRECATED(
5717     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePrivateDataSlotEXT>
5718   {
5719     using type = VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT;
5720   };
5721 
5722   template <>
5723   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlotEXT>
5724   {
5725     using Type = VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT;
5726   };
5727 
5728   template <>
5729   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT>
5730   {
5731     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5732   };
5733 
5734   class RenderPass
5735   {
5736   public:
5737     using CType = VkRenderPass;
5738 
5739     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5740       VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass;
5741     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5742       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass;
5743 
5744   public:
5745     VULKAN_HPP_CONSTEXPR         RenderPass() = default;
RenderPass(std::nullptr_t)5746     VULKAN_HPP_CONSTEXPR         RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
RenderPass(VkRenderPass renderPass)5747     VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT : m_renderPass( renderPass )
5748     {}
5749 
5750 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkRenderPass renderPass)5751     RenderPass & operator=( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT
5752     {
5753       m_renderPass = renderPass;
5754       return *this;
5755     }
5756 #endif
5757 
operator =(std::nullptr_t)5758     RenderPass & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5759     {
5760       m_renderPass = {};
5761       return *this;
5762     }
5763 
5764 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5765     auto operator<=>( RenderPass const & ) const = default;
5766 #else
operator ==(RenderPass const & rhs) const5767     bool operator==( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
5768     {
5769       return m_renderPass == rhs.m_renderPass;
5770     }
5771 
operator !=(RenderPass const & rhs) const5772     bool operator!=( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
5773     {
5774       return m_renderPass != rhs.m_renderPass;
5775     }
5776 
operator <(RenderPass const & rhs) const5777     bool operator<( RenderPass const & rhs ) const VULKAN_HPP_NOEXCEPT
5778     {
5779       return m_renderPass < rhs.m_renderPass;
5780     }
5781 #endif
5782 
operator VkRenderPass() const5783     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const VULKAN_HPP_NOEXCEPT
5784     {
5785       return m_renderPass;
5786     }
5787 
operator bool() const5788     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5789     {
5790       return m_renderPass != VK_NULL_HANDLE;
5791     }
5792 
operator !() const5793     bool operator!() const VULKAN_HPP_NOEXCEPT
5794     {
5795       return m_renderPass == VK_NULL_HANDLE;
5796     }
5797 
5798   private:
5799     VkRenderPass m_renderPass = {};
5800   };
5801   static_assert( sizeof( VULKAN_HPP_NAMESPACE::RenderPass ) == sizeof( VkRenderPass ),
5802                  "handle and wrapper have different size!" );
5803 
5804   template <>
5805   struct VULKAN_HPP_DEPRECATED(
5806     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eRenderPass>
5807   {
5808     using type = VULKAN_HPP_NAMESPACE::RenderPass;
5809   };
5810 
5811   template <>
5812   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass>
5813   {
5814     using Type = VULKAN_HPP_NAMESPACE::RenderPass;
5815   };
5816 
5817   template <>
5818   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5819                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass>
5820   {
5821     using Type = VULKAN_HPP_NAMESPACE::RenderPass;
5822   };
5823 
5824   template <>
5825   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::RenderPass>
5826   {
5827     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5828   };
5829 
5830   class Sampler
5831   {
5832   public:
5833     using CType = VkSampler;
5834 
5835     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5836       VULKAN_HPP_NAMESPACE::ObjectType::eSampler;
5837     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5838       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler;
5839 
5840   public:
5841     VULKAN_HPP_CONSTEXPR         Sampler() = default;
Sampler(std::nullptr_t)5842     VULKAN_HPP_CONSTEXPR         Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Sampler(VkSampler sampler)5843     VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) VULKAN_HPP_NOEXCEPT : m_sampler( sampler ) {}
5844 
5845 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkSampler sampler)5846     Sampler & operator=( VkSampler sampler ) VULKAN_HPP_NOEXCEPT
5847     {
5848       m_sampler = sampler;
5849       return *this;
5850     }
5851 #endif
5852 
operator =(std::nullptr_t)5853     Sampler & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5854     {
5855       m_sampler = {};
5856       return *this;
5857     }
5858 
5859 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5860     auto operator<=>( Sampler const & ) const = default;
5861 #else
operator ==(Sampler const & rhs) const5862     bool operator==( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
5863     {
5864       return m_sampler == rhs.m_sampler;
5865     }
5866 
operator !=(Sampler const & rhs) const5867     bool operator!=( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
5868     {
5869       return m_sampler != rhs.m_sampler;
5870     }
5871 
operator <(Sampler const & rhs) const5872     bool operator<( Sampler const & rhs ) const VULKAN_HPP_NOEXCEPT
5873     {
5874       return m_sampler < rhs.m_sampler;
5875     }
5876 #endif
5877 
operator VkSampler() const5878     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const VULKAN_HPP_NOEXCEPT
5879     {
5880       return m_sampler;
5881     }
5882 
operator bool() const5883     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5884     {
5885       return m_sampler != VK_NULL_HANDLE;
5886     }
5887 
operator !() const5888     bool operator!() const VULKAN_HPP_NOEXCEPT
5889     {
5890       return m_sampler == VK_NULL_HANDLE;
5891     }
5892 
5893   private:
5894     VkSampler m_sampler = {};
5895   };
5896   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Sampler ) == sizeof( VkSampler ),
5897                  "handle and wrapper have different size!" );
5898 
5899   template <>
5900   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSampler>
5901   {
5902     using type = VULKAN_HPP_NAMESPACE::Sampler;
5903   };
5904 
5905   template <>
5906   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSampler>
5907   {
5908     using Type = VULKAN_HPP_NAMESPACE::Sampler;
5909   };
5910 
5911   template <>
5912   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
5913                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler>
5914   {
5915     using Type = VULKAN_HPP_NAMESPACE::Sampler;
5916   };
5917 
5918   template <>
5919   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Sampler>
5920   {
5921     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
5922   };
5923 
5924   class SamplerYcbcrConversion
5925   {
5926   public:
5927     using CType = VkSamplerYcbcrConversion;
5928 
5929     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
5930       VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion;
5931     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
5932       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion;
5933 
5934   public:
5935     VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion() = default;
SamplerYcbcrConversion(std::nullptr_t)5936     VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
5937     VULKAN_HPP_TYPESAFE_EXPLICIT
SamplerYcbcrConversion(VkSamplerYcbcrConversion samplerYcbcrConversion)5938       SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
5939       : m_samplerYcbcrConversion( samplerYcbcrConversion )
5940     {}
5941 
5942 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkSamplerYcbcrConversion samplerYcbcrConversion)5943     SamplerYcbcrConversion & operator=( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT
5944     {
5945       m_samplerYcbcrConversion = samplerYcbcrConversion;
5946       return *this;
5947     }
5948 #endif
5949 
operator =(std::nullptr_t)5950     SamplerYcbcrConversion & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
5951     {
5952       m_samplerYcbcrConversion = {};
5953       return *this;
5954     }
5955 
5956 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
5957     auto operator<=>( SamplerYcbcrConversion const & ) const = default;
5958 #else
operator ==(SamplerYcbcrConversion const & rhs) const5959     bool operator==( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
5960     {
5961       return m_samplerYcbcrConversion == rhs.m_samplerYcbcrConversion;
5962     }
5963 
operator !=(SamplerYcbcrConversion const & rhs) const5964     bool operator!=( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
5965     {
5966       return m_samplerYcbcrConversion != rhs.m_samplerYcbcrConversion;
5967     }
5968 
operator <(SamplerYcbcrConversion const & rhs) const5969     bool operator<( SamplerYcbcrConversion const & rhs ) const VULKAN_HPP_NOEXCEPT
5970     {
5971       return m_samplerYcbcrConversion < rhs.m_samplerYcbcrConversion;
5972     }
5973 #endif
5974 
operator VkSamplerYcbcrConversion() const5975     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT
5976     {
5977       return m_samplerYcbcrConversion;
5978     }
5979 
operator bool() const5980     explicit operator bool() const VULKAN_HPP_NOEXCEPT
5981     {
5982       return m_samplerYcbcrConversion != VK_NULL_HANDLE;
5983     }
5984 
operator !() const5985     bool operator!() const VULKAN_HPP_NOEXCEPT
5986     {
5987       return m_samplerYcbcrConversion == VK_NULL_HANDLE;
5988     }
5989 
5990   private:
5991     VkSamplerYcbcrConversion m_samplerYcbcrConversion = {};
5992   };
5993   static_assert( sizeof( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ),
5994                  "handle and wrapper have different size!" );
5995 
5996   template <>
5997   struct VULKAN_HPP_DEPRECATED(
5998     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eSamplerYcbcrConversion>
5999   {
6000     using type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
6001   };
6002 
6003   template <>
6004   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion>
6005   {
6006     using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
6007   };
6008 
6009   template <>
6010   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
6011                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion>
6012   {
6013     using Type = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion;
6014   };
6015 
6016   template <>
6017   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
6018   {
6019     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6020   };
6021   using SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
6022 
6023   class ShaderModule
6024   {
6025   public:
6026     using CType = VkShaderModule;
6027 
6028     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6029       VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule;
6030     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6031       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule;
6032 
6033   public:
6034     VULKAN_HPP_CONSTEXPR         ShaderModule() = default;
ShaderModule(std::nullptr_t)6035     VULKAN_HPP_CONSTEXPR         ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
ShaderModule(VkShaderModule shaderModule)6036     VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT
6037       : m_shaderModule( shaderModule )
6038     {}
6039 
6040 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkShaderModule shaderModule)6041     ShaderModule & operator=( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT
6042     {
6043       m_shaderModule = shaderModule;
6044       return *this;
6045     }
6046 #endif
6047 
operator =(std::nullptr_t)6048     ShaderModule & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6049     {
6050       m_shaderModule = {};
6051       return *this;
6052     }
6053 
6054 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6055     auto operator<=>( ShaderModule const & ) const = default;
6056 #else
operator ==(ShaderModule const & rhs) const6057     bool operator==( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
6058     {
6059       return m_shaderModule == rhs.m_shaderModule;
6060     }
6061 
operator !=(ShaderModule const & rhs) const6062     bool operator!=( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
6063     {
6064       return m_shaderModule != rhs.m_shaderModule;
6065     }
6066 
operator <(ShaderModule const & rhs) const6067     bool operator<( ShaderModule const & rhs ) const VULKAN_HPP_NOEXCEPT
6068     {
6069       return m_shaderModule < rhs.m_shaderModule;
6070     }
6071 #endif
6072 
operator VkShaderModule() const6073     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const VULKAN_HPP_NOEXCEPT
6074     {
6075       return m_shaderModule;
6076     }
6077 
operator bool() const6078     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6079     {
6080       return m_shaderModule != VK_NULL_HANDLE;
6081     }
6082 
operator !() const6083     bool operator!() const VULKAN_HPP_NOEXCEPT
6084     {
6085       return m_shaderModule == VK_NULL_HANDLE;
6086     }
6087 
6088   private:
6089     VkShaderModule m_shaderModule = {};
6090   };
6091   static_assert( sizeof( VULKAN_HPP_NAMESPACE::ShaderModule ) == sizeof( VkShaderModule ),
6092                  "handle and wrapper have different size!" );
6093 
6094   template <>
6095   struct VULKAN_HPP_DEPRECATED(
6096     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eShaderModule>
6097   {
6098     using type = VULKAN_HPP_NAMESPACE::ShaderModule;
6099   };
6100 
6101   template <>
6102   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule>
6103   {
6104     using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
6105   };
6106 
6107   template <>
6108   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
6109                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule>
6110   {
6111     using Type = VULKAN_HPP_NAMESPACE::ShaderModule;
6112   };
6113 
6114   template <>
6115   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ShaderModule>
6116   {
6117     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6118   };
6119 
6120   class ValidationCacheEXT
6121   {
6122   public:
6123     using CType = VkValidationCacheEXT;
6124 
6125     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6126       VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT;
6127     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6128       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT;
6129 
6130   public:
6131     VULKAN_HPP_CONSTEXPR         ValidationCacheEXT() = default;
ValidationCacheEXT(std::nullptr_t)6132     VULKAN_HPP_CONSTEXPR         ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
ValidationCacheEXT(VkValidationCacheEXT validationCacheEXT)6133     VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT
6134       : m_validationCacheEXT( validationCacheEXT )
6135     {}
6136 
6137 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkValidationCacheEXT validationCacheEXT)6138     ValidationCacheEXT & operator=( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT
6139     {
6140       m_validationCacheEXT = validationCacheEXT;
6141       return *this;
6142     }
6143 #endif
6144 
operator =(std::nullptr_t)6145     ValidationCacheEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6146     {
6147       m_validationCacheEXT = {};
6148       return *this;
6149     }
6150 
6151 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6152     auto operator<=>( ValidationCacheEXT const & ) const = default;
6153 #else
operator ==(ValidationCacheEXT const & rhs) const6154     bool operator==( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
6155     {
6156       return m_validationCacheEXT == rhs.m_validationCacheEXT;
6157     }
6158 
operator !=(ValidationCacheEXT const & rhs) const6159     bool operator!=( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
6160     {
6161       return m_validationCacheEXT != rhs.m_validationCacheEXT;
6162     }
6163 
operator <(ValidationCacheEXT const & rhs) const6164     bool operator<( ValidationCacheEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
6165     {
6166       return m_validationCacheEXT < rhs.m_validationCacheEXT;
6167     }
6168 #endif
6169 
operator VkValidationCacheEXT() const6170     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const VULKAN_HPP_NOEXCEPT
6171     {
6172       return m_validationCacheEXT;
6173     }
6174 
operator bool() const6175     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6176     {
6177       return m_validationCacheEXT != VK_NULL_HANDLE;
6178     }
6179 
operator !() const6180     bool operator!() const VULKAN_HPP_NOEXCEPT
6181     {
6182       return m_validationCacheEXT == VK_NULL_HANDLE;
6183     }
6184 
6185   private:
6186     VkValidationCacheEXT m_validationCacheEXT = {};
6187   };
6188   static_assert( sizeof( VULKAN_HPP_NAMESPACE::ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ),
6189                  "handle and wrapper have different size!" );
6190 
6191   template <>
6192   struct VULKAN_HPP_DEPRECATED(
6193     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eValidationCacheEXT>
6194   {
6195     using type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
6196   };
6197 
6198   template <>
6199   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT>
6200   {
6201     using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
6202   };
6203 
6204   template <>
6205   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
6206                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT>
6207   {
6208     using Type = VULKAN_HPP_NAMESPACE::ValidationCacheEXT;
6209   };
6210 
6211   template <>
6212   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>
6213   {
6214     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6215   };
6216 
6217 #if defined( VK_ENABLE_BETA_EXTENSIONS )
6218   class VideoSessionParametersKHR
6219   {
6220   public:
6221     using CType = VkVideoSessionParametersKHR;
6222 
6223     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6224       VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR;
6225     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6226       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
6227 
6228   public:
6229     VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR() = default;
VideoSessionParametersKHR(std::nullptr_t)6230     VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
6231     VULKAN_HPP_TYPESAFE_EXPLICIT
VideoSessionParametersKHR(VkVideoSessionParametersKHR videoSessionParametersKHR)6232       VideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
6233       : m_videoSessionParametersKHR( videoSessionParametersKHR )
6234     {}
6235 
6236 #  if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkVideoSessionParametersKHR videoSessionParametersKHR)6237     VideoSessionParametersKHR & operator=( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT
6238     {
6239       m_videoSessionParametersKHR = videoSessionParametersKHR;
6240       return *this;
6241     }
6242 #  endif
6243 
operator =(std::nullptr_t)6244     VideoSessionParametersKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6245     {
6246       m_videoSessionParametersKHR = {};
6247       return *this;
6248     }
6249 
6250 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6251     auto operator<=>( VideoSessionParametersKHR const & ) const = default;
6252 #  else
operator ==(VideoSessionParametersKHR const & rhs) const6253     bool operator==( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6254     {
6255       return m_videoSessionParametersKHR == rhs.m_videoSessionParametersKHR;
6256     }
6257 
operator !=(VideoSessionParametersKHR const & rhs) const6258     bool operator!=( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6259     {
6260       return m_videoSessionParametersKHR != rhs.m_videoSessionParametersKHR;
6261     }
6262 
operator <(VideoSessionParametersKHR const & rhs) const6263     bool operator<( VideoSessionParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
6264     {
6265       return m_videoSessionParametersKHR < rhs.m_videoSessionParametersKHR;
6266     }
6267 #  endif
6268 
operator VkVideoSessionParametersKHR() const6269     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT
6270     {
6271       return m_videoSessionParametersKHR;
6272     }
6273 
operator bool() const6274     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6275     {
6276       return m_videoSessionParametersKHR != VK_NULL_HANDLE;
6277     }
6278 
operator !() const6279     bool operator!() const VULKAN_HPP_NOEXCEPT
6280     {
6281       return m_videoSessionParametersKHR == VK_NULL_HANDLE;
6282     }
6283 
6284   private:
6285     VkVideoSessionParametersKHR m_videoSessionParametersKHR = {};
6286   };
6287   static_assert( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR ) == sizeof( VkVideoSessionParametersKHR ),
6288                  "handle and wrapper have different size!" );
6289 
6290   template <>
6291   struct VULKAN_HPP_DEPRECATED(
6292     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eVideoSessionParametersKHR>
6293   {
6294     using type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;
6295   };
6296 
6297   template <>
6298   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR>
6299   {
6300     using Type = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR;
6301   };
6302 
6303   template <>
6304   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>
6305   {
6306     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6307   };
6308 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
6309 
6310   class Queue
6311   {
6312   public:
6313     using CType = VkQueue;
6314 
6315     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6316       VULKAN_HPP_NAMESPACE::ObjectType::eQueue;
6317     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6318       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue;
6319 
6320   public:
6321     VULKAN_HPP_CONSTEXPR         Queue() = default;
Queue(std::nullptr_t)6322     VULKAN_HPP_CONSTEXPR         Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Queue(VkQueue queue)6323     VULKAN_HPP_TYPESAFE_EXPLICIT Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT : m_queue( queue ) {}
6324 
6325 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkQueue queue)6326     Queue & operator=( VkQueue queue ) VULKAN_HPP_NOEXCEPT
6327     {
6328       m_queue = queue;
6329       return *this;
6330     }
6331 #endif
6332 
operator =(std::nullptr_t)6333     Queue & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6334     {
6335       m_queue = {};
6336       return *this;
6337     }
6338 
6339 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6340     auto operator<=>( Queue const & ) const = default;
6341 #else
operator ==(Queue const & rhs) const6342     bool operator==( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
6343     {
6344       return m_queue == rhs.m_queue;
6345     }
6346 
operator !=(Queue const & rhs) const6347     bool operator!=( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
6348     {
6349       return m_queue != rhs.m_queue;
6350     }
6351 
operator <(Queue const & rhs) const6352     bool operator<( Queue const & rhs ) const VULKAN_HPP_NOEXCEPT
6353     {
6354       return m_queue < rhs.m_queue;
6355     }
6356 #endif
6357 
6358     //=== VK_VERSION_1_0 ===
6359 
6360     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6361     VULKAN_HPP_NODISCARD Result
6362                          submit( uint32_t                                 submitCount,
6363                                  const VULKAN_HPP_NAMESPACE::SubmitInfo * pSubmits,
6364                                  VULKAN_HPP_NAMESPACE::Fence              fence,
6365                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6366 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6367     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6368     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6369       submit( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,
6370               VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
6371               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6372 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6373 
6374 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
6375     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6376     VULKAN_HPP_NODISCARD Result
6377                          waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6378 #else
6379     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6380     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6381       waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6382 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6383 
6384     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6385     VULKAN_HPP_NODISCARD Result
6386                          bindSparse( uint32_t                                     bindInfoCount,
6387                                      const VULKAN_HPP_NAMESPACE::BindSparseInfo * pBindInfo,
6388                                      VULKAN_HPP_NAMESPACE::Fence                  fence,
6389                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6390 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6391     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6392     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6393       bindSparse( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,
6394                   VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
6395                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6396 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6397 
6398     //=== VK_KHR_swapchain ===
6399 
6400     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6401     VULKAN_HPP_NODISCARD Result
6402                          presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR * pPresentInfo,
6403                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6404 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6405     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6406     VULKAN_HPP_NODISCARD Result presentKHR( const PresentInfoKHR & presentInfo,
6407                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6408 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6409 
6410     //=== VK_EXT_debug_utils ===
6411 
6412     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6413     void
6414       beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
6415                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6416 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6417     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6418     void
6419       beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
6420                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6421 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6422 
6423     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6424     void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6425 
6426     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6427     void
6428       insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * pLabelInfo,
6429                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6430 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6431     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6432     void
6433       insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo,
6434                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6435 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6436 
6437     //=== VK_NV_device_diagnostic_checkpoints ===
6438 
6439     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6440     void getCheckpointDataNV( uint32_t *                               pCheckpointDataCount,
6441                               VULKAN_HPP_NAMESPACE::CheckpointDataNV * pCheckpointData,
6442                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6443 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6444     template <typename CheckpointDataNVAllocator = std::allocator<CheckpointDataNV>,
6445               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6446     VULKAN_HPP_NODISCARD std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
6447                          getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6448     template <typename CheckpointDataNVAllocator = std::allocator<CheckpointDataNV>,
6449               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
6450               typename B                         = CheckpointDataNVAllocator,
6451               typename std::enable_if<std::is_same<typename B::value_type, CheckpointDataNV>::value, int>::type = 0>
6452     VULKAN_HPP_NODISCARD std::vector<CheckpointDataNV, CheckpointDataNVAllocator>
6453                          getCheckpointDataNV( CheckpointDataNVAllocator & checkpointDataNVAllocator,
6454                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6455 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6456 
6457     //=== VK_INTEL_performance_query ===
6458 
6459 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
6460     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6461     VULKAN_HPP_NODISCARD Result setPerformanceConfigurationINTEL(
6462       VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
6463       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6464 #else
6465     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6466     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6467          setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
6468                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6469 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6470 
6471     //=== VK_KHR_synchronization2 ===
6472 
6473     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6474     VULKAN_HPP_NODISCARD Result
6475                          submit2KHR( uint32_t                                     submitCount,
6476                                      const VULKAN_HPP_NAMESPACE::SubmitInfo2KHR * pSubmits,
6477                                      VULKAN_HPP_NAMESPACE::Fence                  fence,
6478                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6479 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6480     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6481     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6482       submit2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2KHR> const & submits,
6483                   VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
6484                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6485 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6486 
6487     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6488     void getCheckpointData2NV( uint32_t *                                pCheckpointDataCount,
6489                                VULKAN_HPP_NAMESPACE::CheckpointData2NV * pCheckpointData,
6490                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6491 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6492     template <typename CheckpointData2NVAllocator = std::allocator<CheckpointData2NV>,
6493               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6494     VULKAN_HPP_NODISCARD std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
6495                          getCheckpointData2NV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6496     template <typename CheckpointData2NVAllocator = std::allocator<CheckpointData2NV>,
6497               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
6498               typename B                          = CheckpointData2NVAllocator,
6499               typename std::enable_if<std::is_same<typename B::value_type, CheckpointData2NV>::value, int>::type = 0>
6500     VULKAN_HPP_NODISCARD std::vector<CheckpointData2NV, CheckpointData2NVAllocator>
6501                          getCheckpointData2NV( CheckpointData2NVAllocator & checkpointData2NVAllocator,
6502                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6503 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6504 
operator VkQueue() const6505     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueue() const VULKAN_HPP_NOEXCEPT
6506     {
6507       return m_queue;
6508     }
6509 
operator bool() const6510     explicit operator bool() const VULKAN_HPP_NOEXCEPT
6511     {
6512       return m_queue != VK_NULL_HANDLE;
6513     }
6514 
operator !() const6515     bool operator!() const VULKAN_HPP_NOEXCEPT
6516     {
6517       return m_queue == VK_NULL_HANDLE;
6518     }
6519 
6520   private:
6521     VkQueue m_queue = {};
6522   };
6523   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Queue ) == sizeof( VkQueue ),
6524                  "handle and wrapper have different size!" );
6525 
6526   template <>
6527   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eQueue>
6528   {
6529     using type = VULKAN_HPP_NAMESPACE::Queue;
6530   };
6531 
6532   template <>
6533   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eQueue>
6534   {
6535     using Type = VULKAN_HPP_NAMESPACE::Queue;
6536   };
6537 
6538   template <>
6539   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT, VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue>
6540   {
6541     using Type = VULKAN_HPP_NAMESPACE::Queue;
6542   };
6543 
6544   template <>
6545   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Queue>
6546   {
6547     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
6548   };
6549 
6550 #ifndef VULKAN_HPP_NO_SMART_HANDLE
6551   class Device;
6552   template <typename Dispatch>
6553   class UniqueHandleTraits<AccelerationStructureKHR, Dispatch>
6554   {
6555   public:
6556     using deleter = ObjectDestroy<Device, Dispatch>;
6557   };
6558   using UniqueAccelerationStructureKHR = UniqueHandle<AccelerationStructureKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6559   template <typename Dispatch>
6560   class UniqueHandleTraits<AccelerationStructureNV, Dispatch>
6561   {
6562   public:
6563     using deleter = ObjectDestroy<Device, Dispatch>;
6564   };
6565   using UniqueAccelerationStructureNV = UniqueHandle<AccelerationStructureNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6566   template <typename Dispatch>
6567   class UniqueHandleTraits<Buffer, Dispatch>
6568   {
6569   public:
6570     using deleter = ObjectDestroy<Device, Dispatch>;
6571   };
6572   using UniqueBuffer = UniqueHandle<Buffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6573   template <typename Dispatch>
6574   class UniqueHandleTraits<BufferView, Dispatch>
6575   {
6576   public:
6577     using deleter = ObjectDestroy<Device, Dispatch>;
6578   };
6579   using UniqueBufferView = UniqueHandle<BufferView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6580   template <typename Dispatch>
6581   class UniqueHandleTraits<CommandBuffer, Dispatch>
6582   {
6583   public:
6584     using deleter = PoolFree<Device, CommandPool, Dispatch>;
6585   };
6586   using UniqueCommandBuffer = UniqueHandle<CommandBuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6587   template <typename Dispatch>
6588   class UniqueHandleTraits<CommandPool, Dispatch>
6589   {
6590   public:
6591     using deleter = ObjectDestroy<Device, Dispatch>;
6592   };
6593   using UniqueCommandPool = UniqueHandle<CommandPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6594   template <typename Dispatch>
6595   class UniqueHandleTraits<CuFunctionNVX, Dispatch>
6596   {
6597   public:
6598     using deleter = ObjectDestroy<Device, Dispatch>;
6599   };
6600   using UniqueCuFunctionNVX = UniqueHandle<CuFunctionNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6601   template <typename Dispatch>
6602   class UniqueHandleTraits<CuModuleNVX, Dispatch>
6603   {
6604   public:
6605     using deleter = ObjectDestroy<Device, Dispatch>;
6606   };
6607   using UniqueCuModuleNVX = UniqueHandle<CuModuleNVX, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6608   template <typename Dispatch>
6609   class UniqueHandleTraits<DeferredOperationKHR, Dispatch>
6610   {
6611   public:
6612     using deleter = ObjectDestroy<Device, Dispatch>;
6613   };
6614   using UniqueDeferredOperationKHR = UniqueHandle<DeferredOperationKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6615   template <typename Dispatch>
6616   class UniqueHandleTraits<DescriptorPool, Dispatch>
6617   {
6618   public:
6619     using deleter = ObjectDestroy<Device, Dispatch>;
6620   };
6621   using UniqueDescriptorPool = UniqueHandle<DescriptorPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6622   template <typename Dispatch>
6623   class UniqueHandleTraits<DescriptorSet, Dispatch>
6624   {
6625   public:
6626     using deleter = PoolFree<Device, DescriptorPool, Dispatch>;
6627   };
6628   using UniqueDescriptorSet = UniqueHandle<DescriptorSet, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6629   template <typename Dispatch>
6630   class UniqueHandleTraits<DescriptorSetLayout, Dispatch>
6631   {
6632   public:
6633     using deleter = ObjectDestroy<Device, Dispatch>;
6634   };
6635   using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6636   template <typename Dispatch>
6637   class UniqueHandleTraits<DescriptorUpdateTemplate, Dispatch>
6638   {
6639   public:
6640     using deleter = ObjectDestroy<Device, Dispatch>;
6641   };
6642   using UniqueDescriptorUpdateTemplate    = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6643   using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplate, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6644   template <typename Dispatch>
6645   class UniqueHandleTraits<DeviceMemory, Dispatch>
6646   {
6647   public:
6648     using deleter = ObjectFree<Device, Dispatch>;
6649   };
6650   using UniqueDeviceMemory = UniqueHandle<DeviceMemory, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6651   template <typename Dispatch>
6652   class UniqueHandleTraits<Event, Dispatch>
6653   {
6654   public:
6655     using deleter = ObjectDestroy<Device, Dispatch>;
6656   };
6657   using UniqueEvent = UniqueHandle<Event, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6658   template <typename Dispatch>
6659   class UniqueHandleTraits<Fence, Dispatch>
6660   {
6661   public:
6662     using deleter = ObjectDestroy<Device, Dispatch>;
6663   };
6664   using UniqueFence = UniqueHandle<Fence, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6665   template <typename Dispatch>
6666   class UniqueHandleTraits<Framebuffer, Dispatch>
6667   {
6668   public:
6669     using deleter = ObjectDestroy<Device, Dispatch>;
6670   };
6671   using UniqueFramebuffer = UniqueHandle<Framebuffer, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6672   template <typename Dispatch>
6673   class UniqueHandleTraits<Image, Dispatch>
6674   {
6675   public:
6676     using deleter = ObjectDestroy<Device, Dispatch>;
6677   };
6678   using UniqueImage = UniqueHandle<Image, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6679   template <typename Dispatch>
6680   class UniqueHandleTraits<ImageView, Dispatch>
6681   {
6682   public:
6683     using deleter = ObjectDestroy<Device, Dispatch>;
6684   };
6685   using UniqueImageView = UniqueHandle<ImageView, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6686   template <typename Dispatch>
6687   class UniqueHandleTraits<IndirectCommandsLayoutNV, Dispatch>
6688   {
6689   public:
6690     using deleter = ObjectDestroy<Device, Dispatch>;
6691   };
6692   using UniqueIndirectCommandsLayoutNV = UniqueHandle<IndirectCommandsLayoutNV, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6693   template <typename Dispatch>
6694   class UniqueHandleTraits<Pipeline, Dispatch>
6695   {
6696   public:
6697     using deleter = ObjectDestroy<Device, Dispatch>;
6698   };
6699   using UniquePipeline = UniqueHandle<Pipeline, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6700   template <typename Dispatch>
6701   class UniqueHandleTraits<PipelineCache, Dispatch>
6702   {
6703   public:
6704     using deleter = ObjectDestroy<Device, Dispatch>;
6705   };
6706   using UniquePipelineCache = UniqueHandle<PipelineCache, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6707   template <typename Dispatch>
6708   class UniqueHandleTraits<PipelineLayout, Dispatch>
6709   {
6710   public:
6711     using deleter = ObjectDestroy<Device, Dispatch>;
6712   };
6713   using UniquePipelineLayout = UniqueHandle<PipelineLayout, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6714   template <typename Dispatch>
6715   class UniqueHandleTraits<PrivateDataSlotEXT, Dispatch>
6716   {
6717   public:
6718     using deleter = ObjectDestroy<Device, Dispatch>;
6719   };
6720   using UniquePrivateDataSlotEXT = UniqueHandle<PrivateDataSlotEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6721   template <typename Dispatch>
6722   class UniqueHandleTraits<QueryPool, Dispatch>
6723   {
6724   public:
6725     using deleter = ObjectDestroy<Device, Dispatch>;
6726   };
6727   using UniqueQueryPool = UniqueHandle<QueryPool, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6728   template <typename Dispatch>
6729   class UniqueHandleTraits<RenderPass, Dispatch>
6730   {
6731   public:
6732     using deleter = ObjectDestroy<Device, Dispatch>;
6733   };
6734   using UniqueRenderPass = UniqueHandle<RenderPass, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6735   template <typename Dispatch>
6736   class UniqueHandleTraits<Sampler, Dispatch>
6737   {
6738   public:
6739     using deleter = ObjectDestroy<Device, Dispatch>;
6740   };
6741   using UniqueSampler = UniqueHandle<Sampler, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6742   template <typename Dispatch>
6743   class UniqueHandleTraits<SamplerYcbcrConversion, Dispatch>
6744   {
6745   public:
6746     using deleter = ObjectDestroy<Device, Dispatch>;
6747   };
6748   using UniqueSamplerYcbcrConversion    = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6749   using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversion, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6750   template <typename Dispatch>
6751   class UniqueHandleTraits<Semaphore, Dispatch>
6752   {
6753   public:
6754     using deleter = ObjectDestroy<Device, Dispatch>;
6755   };
6756   using UniqueSemaphore = UniqueHandle<Semaphore, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6757   template <typename Dispatch>
6758   class UniqueHandleTraits<ShaderModule, Dispatch>
6759   {
6760   public:
6761     using deleter = ObjectDestroy<Device, Dispatch>;
6762   };
6763   using UniqueShaderModule = UniqueHandle<ShaderModule, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6764   template <typename Dispatch>
6765   class UniqueHandleTraits<SwapchainKHR, Dispatch>
6766   {
6767   public:
6768     using deleter = ObjectDestroy<Device, Dispatch>;
6769   };
6770   using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6771   template <typename Dispatch>
6772   class UniqueHandleTraits<ValidationCacheEXT, Dispatch>
6773   {
6774   public:
6775     using deleter = ObjectDestroy<Device, Dispatch>;
6776   };
6777   using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6778 #  if defined( VK_ENABLE_BETA_EXTENSIONS )
6779   template <typename Dispatch>
6780   class UniqueHandleTraits<VideoSessionKHR, Dispatch>
6781   {
6782   public:
6783     using deleter = ObjectDestroy<Device, Dispatch>;
6784   };
6785   using UniqueVideoSessionKHR = UniqueHandle<VideoSessionKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6786 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/
6787 #  if defined( VK_ENABLE_BETA_EXTENSIONS )
6788   template <typename Dispatch>
6789   class UniqueHandleTraits<VideoSessionParametersKHR, Dispatch>
6790   {
6791   public:
6792     using deleter = ObjectDestroy<Device, Dispatch>;
6793   };
6794   using UniqueVideoSessionParametersKHR = UniqueHandle<VideoSessionParametersKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
6795 #  endif /*VK_ENABLE_BETA_EXTENSIONS*/
6796 #endif   /*VULKAN_HPP_NO_SMART_HANDLE*/
6797 
6798   class Device
6799   {
6800   public:
6801     using CType = VkDevice;
6802 
6803     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
6804       VULKAN_HPP_NAMESPACE::ObjectType::eDevice;
6805     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
6806       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice;
6807 
6808   public:
6809     VULKAN_HPP_CONSTEXPR         Device() = default;
Device(std::nullptr_t)6810     VULKAN_HPP_CONSTEXPR         Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Device(VkDevice device)6811     VULKAN_HPP_TYPESAFE_EXPLICIT Device( VkDevice device ) VULKAN_HPP_NOEXCEPT : m_device( device ) {}
6812 
6813 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDevice device)6814     Device & operator=( VkDevice device ) VULKAN_HPP_NOEXCEPT
6815     {
6816       m_device = device;
6817       return *this;
6818     }
6819 #endif
6820 
operator =(std::nullptr_t)6821     Device & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
6822     {
6823       m_device = {};
6824       return *this;
6825     }
6826 
6827 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
6828     auto operator<=>( Device const & ) const = default;
6829 #else
operator ==(Device const & rhs) const6830     bool operator==( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
6831     {
6832       return m_device == rhs.m_device;
6833     }
6834 
operator !=(Device const & rhs) const6835     bool operator!=( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
6836     {
6837       return m_device != rhs.m_device;
6838     }
6839 
operator <(Device const & rhs) const6840     bool operator<( Device const & rhs ) const VULKAN_HPP_NOEXCEPT
6841     {
6842       return m_device < rhs.m_device;
6843     }
6844 #endif
6845 
6846     //=== VK_VERSION_1_0 ===
6847 
6848     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6849     PFN_vkVoidFunction
6850       getProcAddr( const char *     pName,
6851                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6852 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6853     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6854     PFN_vkVoidFunction
6855       getProcAddr( const std::string & name,
6856                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6857 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6858 
6859     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6860     void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
6861                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6862 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6863     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6864     void destroy( Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
6865                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6866 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6867 
6868     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6869     void getQueue( uint32_t                      queueFamilyIndex,
6870                    uint32_t                      queueIndex,
6871                    VULKAN_HPP_NAMESPACE::Queue * pQueue,
6872                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6873 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6874     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6875     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue
6876                          getQueue( uint32_t         queueFamilyIndex,
6877                                    uint32_t         queueIndex,
6878                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6879 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6880 
6881 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
6882     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6883     VULKAN_HPP_NODISCARD Result
6884                          waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6885 #else
6886     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6887     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6888       waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6889 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6890 
6891     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6892     VULKAN_HPP_NODISCARD Result
6893                          allocateMemory( const VULKAN_HPP_NAMESPACE::MemoryAllocateInfo *  pAllocateInfo,
6894                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
6895                                          VULKAN_HPP_NAMESPACE::DeviceMemory *              pMemory,
6896                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6897 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6898     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6899     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceMemory>::type
6900       allocateMemory( const MemoryAllocateInfo &          allocateInfo,
6901                       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
6902                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6903 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
6904     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6905     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
6906       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeviceMemory, Dispatch>>::type
6907       allocateMemoryUnique( const MemoryAllocateInfo &          allocateInfo,
6908                             Optional<const AllocationCallbacks> allocator
6909                                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
6910                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6911 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
6912 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6913 
6914     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6915     void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,
6916                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
6917                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6918 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6919     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6920     void freeMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
6921                      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
6922                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6923 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6924 
6925     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6926     void free( VULKAN_HPP_NAMESPACE::DeviceMemory                memory,
6927                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
6928                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6929 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6930     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6931     void free( VULKAN_HPP_NAMESPACE::DeviceMemory  memory,
6932                Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
6933                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6934 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6935 
6936     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6937     VULKAN_HPP_NODISCARD Result
6938                          mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory   memory,
6939                                     VULKAN_HPP_NAMESPACE::DeviceSize     offset,
6940                                     VULKAN_HPP_NAMESPACE::DeviceSize     size,
6941                                     VULKAN_HPP_NAMESPACE::MemoryMapFlags flags,
6942                                     void **                              ppData,
6943                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6944 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6945     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6946     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void *>::type
6947       mapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory   memory,
6948                  VULKAN_HPP_NAMESPACE::DeviceSize     offset,
6949                  VULKAN_HPP_NAMESPACE::DeviceSize     size,
6950                  VULKAN_HPP_NAMESPACE::MemoryMapFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
6951                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6952 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6953 
6954     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6955     void unmapMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
6956                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6957 
6958     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6959     VULKAN_HPP_NODISCARD Result
6960                          flushMappedMemoryRanges( uint32_t                                        memoryRangeCount,
6961                                                   const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
6962                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6963 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6964     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6965     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6966       flushMappedMemoryRanges( ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
6967                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6968 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6969 
6970     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6971     VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges(
6972       uint32_t                                        memoryRangeCount,
6973       const VULKAN_HPP_NAMESPACE::MappedMemoryRange * pMemoryRanges,
6974       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6975 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6976     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6977     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
6978       invalidateMappedMemoryRanges( ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges,
6979                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
6980 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6981 
6982     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6983     void getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
6984                               VULKAN_HPP_NAMESPACE::DeviceSize * pCommittedMemoryInBytes,
6985                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6986 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
6987     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6988     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize
6989                          getMemoryCommitment( VULKAN_HPP_NAMESPACE::DeviceMemory memory,
6990                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
6991 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
6992 
6993 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
6994     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
6995     VULKAN_HPP_NODISCARD Result
6996                          bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer       buffer,
6997                                            VULKAN_HPP_NAMESPACE::DeviceMemory memory,
6998                                            VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
6999                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7000 #else
7001     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7002     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
7003       bindBufferMemory( VULKAN_HPP_NAMESPACE::Buffer       buffer,
7004                         VULKAN_HPP_NAMESPACE::DeviceMemory memory,
7005                         VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
7006                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7007 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7008 
7009 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7010     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7011     VULKAN_HPP_NODISCARD Result
7012                          bindImageMemory( VULKAN_HPP_NAMESPACE::Image        image,
7013                                           VULKAN_HPP_NAMESPACE::DeviceMemory memory,
7014                                           VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
7015                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7016 #else
7017     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7018     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
7019       bindImageMemory( VULKAN_HPP_NAMESPACE::Image        image,
7020                        VULKAN_HPP_NAMESPACE::DeviceMemory memory,
7021                        VULKAN_HPP_NAMESPACE::DeviceSize   memoryOffset,
7022                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7023 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7024 
7025     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7026     void getBufferMemoryRequirements( VULKAN_HPP_NAMESPACE::Buffer               buffer,
7027                                       VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
7028                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
7029       VULKAN_HPP_NOEXCEPT;
7030 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7031     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7032     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getBufferMemoryRequirements(
7033       VULKAN_HPP_NAMESPACE::Buffer buffer,
7034       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7035 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7036 
7037     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7038     void getImageMemoryRequirements( VULKAN_HPP_NAMESPACE::Image                image,
7039                                      VULKAN_HPP_NAMESPACE::MemoryRequirements * pMemoryRequirements,
7040                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
7041       VULKAN_HPP_NOEXCEPT;
7042 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7043     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7044     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getImageMemoryRequirements(
7045       VULKAN_HPP_NAMESPACE::Image image,
7046       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7047 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7048 
7049     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7050     void getImageSparseMemoryRequirements(
7051       VULKAN_HPP_NAMESPACE::Image                           image,
7052       uint32_t *                                            pSparseMemoryRequirementCount,
7053       VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements * pSparseMemoryRequirements,
7054       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7055 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7056     template <typename SparseImageMemoryRequirementsAllocator = std::allocator<SparseImageMemoryRequirements>,
7057               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7058     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
7059                          getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image image,
7060                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7061     template <typename SparseImageMemoryRequirementsAllocator = std::allocator<SparseImageMemoryRequirements>,
7062               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
7063               typename B                                      = SparseImageMemoryRequirementsAllocator,
7064               typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements>::value,
7065                                       int>::type              = 0>
7066     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements, SparseImageMemoryRequirementsAllocator>
7067                          getImageSparseMemoryRequirements( VULKAN_HPP_NAMESPACE::Image              image,
7068                                                            SparseImageMemoryRequirementsAllocator & sparseImageMemoryRequirementsAllocator,
7069                                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7070 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7071 
7072     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7073     VULKAN_HPP_NODISCARD Result
7074                          createFence( const VULKAN_HPP_NAMESPACE::FenceCreateInfo *     pCreateInfo,
7075                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7076                                       VULKAN_HPP_NAMESPACE::Fence *                     pFence,
7077                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7078 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7079     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7080     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
7081       createFence( const FenceCreateInfo &             createInfo,
7082                    Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7083                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7084 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7085     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7086     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7087       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
7088       createFenceUnique( const FenceCreateInfo &             createInfo,
7089                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7090                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7091 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7092 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7093 
7094     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7095     void destroyFence( VULKAN_HPP_NAMESPACE::Fence                       fence,
7096                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7097                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7098 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7099     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7100     void destroyFence( VULKAN_HPP_NAMESPACE::Fence fence   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7101                        Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7102                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7103 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7104 
7105     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7106     void destroy( VULKAN_HPP_NAMESPACE::Fence                       fence,
7107                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7108                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7109 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7110     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7111     void destroy( VULKAN_HPP_NAMESPACE::Fence         fence,
7112                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7113                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7114 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7115 
7116     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7117     VULKAN_HPP_NODISCARD Result
7118                          resetFences( uint32_t                            fenceCount,
7119                                       const VULKAN_HPP_NAMESPACE::Fence * pFences,
7120                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7121 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7122     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7123     typename ResultValueType<void>::type
7124       resetFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
7125                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7126 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7127 
7128 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7129     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7130     VULKAN_HPP_NODISCARD Result
7131                          getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
7132                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7133 #else
7134     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7135     VULKAN_HPP_NODISCARD Result getFenceStatus( VULKAN_HPP_NAMESPACE::Fence fence,
7136                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7137 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7138 
7139     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7140     VULKAN_HPP_NODISCARD Result
7141                          waitForFences( uint32_t                            fenceCount,
7142                                         const VULKAN_HPP_NAMESPACE::Fence * pFences,
7143                                         VULKAN_HPP_NAMESPACE::Bool32        waitAll,
7144                                         uint64_t                            timeout,
7145                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7146 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7147     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7148     VULKAN_HPP_NODISCARD Result waitForFences( ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
7149                                                VULKAN_HPP_NAMESPACE::Bool32                          waitAll,
7150                                                uint64_t                                              timeout,
7151                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7152 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7153 
7154     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7155     VULKAN_HPP_NODISCARD Result
7156                          createSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo * pCreateInfo,
7157                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7158                                           VULKAN_HPP_NAMESPACE::Semaphore *                 pSemaphore,
7159                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7160 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7161     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7162     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Semaphore>::type
7163       createSemaphore( const SemaphoreCreateInfo &         createInfo,
7164                        Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7165                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7166 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7167     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7168     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7169       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Semaphore, Dispatch>>::type
7170       createSemaphoreUnique( const SemaphoreCreateInfo &         createInfo,
7171                              Optional<const AllocationCallbacks> allocator
7172                                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7173                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7174 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7175 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7176 
7177     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7178     void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,
7179                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7180                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7181 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7182     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7183     void destroySemaphore( VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7184                            Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7185                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7186 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7187 
7188     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7189     void destroy( VULKAN_HPP_NAMESPACE::Semaphore                   semaphore,
7190                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7191                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7192 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7193     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7194     void destroy( VULKAN_HPP_NAMESPACE::Semaphore     semaphore,
7195                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7196                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7197 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7198 
7199     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7200     VULKAN_HPP_NODISCARD Result
7201                          createEvent( const VULKAN_HPP_NAMESPACE::EventCreateInfo *     pCreateInfo,
7202                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7203                                       VULKAN_HPP_NAMESPACE::Event *                     pEvent,
7204                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7205 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7206     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7207     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Event>::type
7208       createEvent( const EventCreateInfo &             createInfo,
7209                    Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7210                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7211 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7212     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7213     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7214       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Event, Dispatch>>::type
7215       createEventUnique( const EventCreateInfo &             createInfo,
7216                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7217                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7218 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7219 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7220 
7221     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7222     void destroyEvent( VULKAN_HPP_NAMESPACE::Event                       event,
7223                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7224                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7225 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7226     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7227     void destroyEvent( VULKAN_HPP_NAMESPACE::Event event   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7228                        Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7229                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7230 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7231 
7232     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7233     void destroy( VULKAN_HPP_NAMESPACE::Event                       event,
7234                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7235                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7236 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7237     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7238     void destroy( VULKAN_HPP_NAMESPACE::Event         event,
7239                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7240                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7241 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7242 
7243 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7244     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7245     VULKAN_HPP_NODISCARD Result
7246                          getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
7247                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7248 #else
7249     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7250     VULKAN_HPP_NODISCARD Result getEventStatus( VULKAN_HPP_NAMESPACE::Event event,
7251                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7252 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7253 
7254 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7255     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7256     VULKAN_HPP_NODISCARD Result
7257                          setEvent( VULKAN_HPP_NAMESPACE::Event event,
7258                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7259 #else
7260     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7261     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
7262       setEvent( VULKAN_HPP_NAMESPACE::Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7263 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7264 
7265 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
7266     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7267     VULKAN_HPP_NODISCARD Result
7268                          resetEvent( VULKAN_HPP_NAMESPACE::Event event,
7269                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7270 #else
7271     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7272     typename ResultValueType<void>::type
7273       resetEvent( VULKAN_HPP_NAMESPACE::Event event,
7274                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7275 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7276 
7277     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7278     VULKAN_HPP_NODISCARD Result
7279                          createQueryPool( const VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo * pCreateInfo,
7280                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7281                                           VULKAN_HPP_NAMESPACE::QueryPool *                 pQueryPool,
7282                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7283 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7284     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7285     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::QueryPool>::type
7286       createQueryPool( const QueryPoolCreateInfo &         createInfo,
7287                        Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7288                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7289 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7290     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7291     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7292       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::QueryPool, Dispatch>>::type
7293       createQueryPoolUnique( const QueryPoolCreateInfo &         createInfo,
7294                              Optional<const AllocationCallbacks> allocator
7295                                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7296                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7297 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7298 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7299 
7300     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7301     void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,
7302                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7303                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7304 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7305     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7306     void destroyQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7307                            Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7308                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7309 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7310 
7311     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7312     void destroy( VULKAN_HPP_NAMESPACE::QueryPool                   queryPool,
7313                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7314                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7315 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7316     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7317     void destroy( VULKAN_HPP_NAMESPACE::QueryPool     queryPool,
7318                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7319                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7320 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7321 
7322     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7323     VULKAN_HPP_NODISCARD Result
7324                          getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
7325                                               uint32_t                               firstQuery,
7326                                               uint32_t                               queryCount,
7327                                               size_t                                 dataSize,
7328                                               void *                                 pData,
7329                                               VULKAN_HPP_NAMESPACE::DeviceSize       stride,
7330                                               VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
7331                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7332 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7333     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7334     VULKAN_HPP_NODISCARD Result
7335                          getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
7336                                               uint32_t                               firstQuery,
7337                                               uint32_t                               queryCount,
7338                                               ArrayProxy<T> const &                  data,
7339                                               VULKAN_HPP_NAMESPACE::DeviceSize       stride,
7340                                               VULKAN_HPP_NAMESPACE::QueryResultFlags flags,
7341                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7342     template <typename T,
7343               typename Allocator = std::allocator<T>,
7344               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7345     VULKAN_HPP_NODISCARD ResultValue<std::vector<T, Allocator>>
7346                          getQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
7347                                               uint32_t                               firstQuery,
7348                                               uint32_t                               queryCount,
7349                                               size_t                                 dataSize,
7350                                               VULKAN_HPP_NAMESPACE::DeviceSize       stride,
7351                                               VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7352                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7353     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7354     VULKAN_HPP_NODISCARD ResultValue<T>
7355                          getQueryPoolResult( VULKAN_HPP_NAMESPACE::QueryPool        queryPool,
7356                                              uint32_t                               firstQuery,
7357                                              uint32_t                               queryCount,
7358                                              VULKAN_HPP_NAMESPACE::DeviceSize       stride,
7359                                              VULKAN_HPP_NAMESPACE::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7360                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7361 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7362 
7363     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7364     VULKAN_HPP_NODISCARD Result
7365                          createBuffer( const VULKAN_HPP_NAMESPACE::BufferCreateInfo *    pCreateInfo,
7366                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7367                                        VULKAN_HPP_NAMESPACE::Buffer *                    pBuffer,
7368                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7369 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7370     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7371     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Buffer>::type
7372       createBuffer( const BufferCreateInfo &            createInfo,
7373                     Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7374                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7375 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7376     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7377     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7378       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Buffer, Dispatch>>::type
7379       createBufferUnique( const BufferCreateInfo &            createInfo,
7380                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7381                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7382 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7383 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7384 
7385     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7386     void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer                      buffer,
7387                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7388                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7389 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7390     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7391     void destroyBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7392                         Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7393                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7394 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7395 
7396     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7397     void destroy( VULKAN_HPP_NAMESPACE::Buffer                      buffer,
7398                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7399                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7400 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7401     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7402     void destroy( VULKAN_HPP_NAMESPACE::Buffer        buffer,
7403                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7404                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7405 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7406 
7407     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7408     VULKAN_HPP_NODISCARD Result
7409                          createBufferView( const VULKAN_HPP_NAMESPACE::BufferViewCreateInfo * pCreateInfo,
7410                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *  pAllocator,
7411                                            VULKAN_HPP_NAMESPACE::BufferView *                 pView,
7412                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7413 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7414     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7415     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::BufferView>::type
7416       createBufferView( const BufferViewCreateInfo &        createInfo,
7417                         Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7418                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7419 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7420     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7421     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7422       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::BufferView, Dispatch>>::type
7423       createBufferViewUnique( const BufferViewCreateInfo &        createInfo,
7424                               Optional<const AllocationCallbacks> allocator
7425                                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7426                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7427 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7428 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7429 
7430     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7431     void destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,
7432                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7433                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7434 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7435     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7436     void
7437       destroyBufferView( VULKAN_HPP_NAMESPACE::BufferView bufferView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7438                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7439                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7440 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7441 
7442     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7443     void destroy( VULKAN_HPP_NAMESPACE::BufferView                  bufferView,
7444                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7445                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7446 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7447     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7448     void destroy( VULKAN_HPP_NAMESPACE::BufferView    bufferView,
7449                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7450                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7451 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7452 
7453     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7454     VULKAN_HPP_NODISCARD Result
7455                          createImage( const VULKAN_HPP_NAMESPACE::ImageCreateInfo *     pCreateInfo,
7456                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7457                                       VULKAN_HPP_NAMESPACE::Image *                     pImage,
7458                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7459 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7460     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7461     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Image>::type
7462       createImage( const ImageCreateInfo &             createInfo,
7463                    Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7464                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7465 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7466     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7467     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7468       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Image, Dispatch>>::type
7469       createImageUnique( const ImageCreateInfo &             createInfo,
7470                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7471                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7472 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7473 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7474 
7475     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7476     void destroyImage( VULKAN_HPP_NAMESPACE::Image                       image,
7477                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7478                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7479 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7480     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7481     void destroyImage( VULKAN_HPP_NAMESPACE::Image image   VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7482                        Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7483                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7484 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7485 
7486     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7487     void destroy( VULKAN_HPP_NAMESPACE::Image                       image,
7488                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7489                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7490 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7491     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7492     void destroy( VULKAN_HPP_NAMESPACE::Image         image,
7493                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7494                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7495 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7496 
7497     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7498     void getImageSubresourceLayout( VULKAN_HPP_NAMESPACE::Image                    image,
7499                                     const VULKAN_HPP_NAMESPACE::ImageSubresource * pSubresource,
7500                                     VULKAN_HPP_NAMESPACE::SubresourceLayout *      pLayout,
7501                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
7502       VULKAN_HPP_NOEXCEPT;
7503 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7504     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7505     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout getImageSubresourceLayout(
7506       VULKAN_HPP_NAMESPACE::Image image,
7507       const ImageSubresource &    subresource,
7508       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7509 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7510 
7511     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7512     VULKAN_HPP_NODISCARD Result
7513                          createImageView( const VULKAN_HPP_NAMESPACE::ImageViewCreateInfo * pCreateInfo,
7514                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7515                                           VULKAN_HPP_NAMESPACE::ImageView *                 pView,
7516                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7517 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7518     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7519     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageView>::type
7520       createImageView( const ImageViewCreateInfo &         createInfo,
7521                        Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7522                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7523 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7524     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7525     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7526       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ImageView, Dispatch>>::type
7527       createImageViewUnique( const ImageViewCreateInfo &         createInfo,
7528                              Optional<const AllocationCallbacks> allocator
7529                                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7530                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7531 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7532 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7533 
7534     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7535     void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView                   imageView,
7536                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7537                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7538 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7539     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7540     void destroyImageView( VULKAN_HPP_NAMESPACE::ImageView imageView VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7541                            Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7542                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7543 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7544 
7545     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7546     void destroy( VULKAN_HPP_NAMESPACE::ImageView                   imageView,
7547                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7548                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7549 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7550     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7551     void destroy( VULKAN_HPP_NAMESPACE::ImageView     imageView,
7552                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7553                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7554 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7555 
7556     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7557     VULKAN_HPP_NODISCARD Result
7558                          createShaderModule( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo * pCreateInfo,
7559                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
7560                                              VULKAN_HPP_NAMESPACE::ShaderModule *                 pShaderModule,
7561                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7562 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7563     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7564     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ShaderModule>::type
7565       createShaderModule( const ShaderModuleCreateInfo &      createInfo,
7566                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7567                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7568 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7569     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7570     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7571       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ShaderModule, Dispatch>>::type
7572       createShaderModuleUnique( const ShaderModuleCreateInfo &      createInfo,
7573                                 Optional<const AllocationCallbacks> allocator
7574                                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7575                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7576 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7577 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7578 
7579     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7580     void destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
7581                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7582                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7583 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7584     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7585     void
7586       destroyShaderModule( VULKAN_HPP_NAMESPACE::ShaderModule shaderModule VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7587                            Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7588                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7589 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7590 
7591     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7592     void destroy( VULKAN_HPP_NAMESPACE::ShaderModule                shaderModule,
7593                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7594                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7595 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7596     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7597     void destroy( VULKAN_HPP_NAMESPACE::ShaderModule  shaderModule,
7598                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7599                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7600 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7601 
7602     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7603     VULKAN_HPP_NODISCARD Result
7604                          createPipelineCache( const VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo * pCreateInfo,
7605                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
7606                                               VULKAN_HPP_NAMESPACE::PipelineCache *                 pPipelineCache,
7607                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7608 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7609     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7610     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineCache>::type
7611       createPipelineCache( const PipelineCacheCreateInfo &     createInfo,
7612                            Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7613                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7614 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7615     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7616     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7617       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineCache, Dispatch>>::type
7618       createPipelineCacheUnique( const PipelineCacheCreateInfo &     createInfo,
7619                                  Optional<const AllocationCallbacks> allocator
7620                                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7621                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7622 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7623 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7624 
7625     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7626     void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,
7627                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7628                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7629 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7630     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7631     void destroyPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7632                                Optional<const AllocationCallbacks>               allocator
7633                                                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7634                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7635 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7636 
7637     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7638     void destroy( VULKAN_HPP_NAMESPACE::PipelineCache               pipelineCache,
7639                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7640                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7641 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7642     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7643     void destroy( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
7644                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7645                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7646 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7647 
7648     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7649     VULKAN_HPP_NODISCARD Result
7650                          getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
7651                                                size_t *                            pDataSize,
7652                                                void *                              pData,
7653                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7654 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7655     template <typename Uint8_tAllocator = std::allocator<uint8_t>,
7656               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7657     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
7658       getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
7659                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7660     template <typename Uint8_tAllocator = std::allocator<uint8_t>,
7661               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
7662               typename B                = Uint8_tAllocator,
7663               typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
7664     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
7665       getPipelineCacheData( VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache,
7666                             Uint8_tAllocator &                  uint8_tAllocator,
7667                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7668 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7669 
7670     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7671     VULKAN_HPP_NODISCARD Result
7672                          mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache         dstCache,
7673                                               uint32_t                                    srcCacheCount,
7674                                               const VULKAN_HPP_NAMESPACE::PipelineCache * pSrcCaches,
7675                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7676 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7677     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7678     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
7679       mergePipelineCaches( VULKAN_HPP_NAMESPACE::PipelineCache                           dstCache,
7680                            ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches,
7681                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7682 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7683 
7684     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7685     VULKAN_HPP_NODISCARD Result
7686                          createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
7687                                                   uint32_t                                                 createInfoCount,
7688                                                   const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo * pCreateInfos,
7689                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,
7690                                                   VULKAN_HPP_NAMESPACE::Pipeline *                         pPipelines,
7691                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7692 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7693     template <typename PipelineAllocator = std::allocator<Pipeline>,
7694               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7695     VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createGraphicsPipelines(
7696       VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
7697       ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
7698       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7699       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7700     template <typename PipelineAllocator = std::allocator<Pipeline>,
7701               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
7702               typename B                 = PipelineAllocator,
7703               typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
7704     VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
7705                          createGraphicsPipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
7706                                                   ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
7707                                                   Optional<const AllocationCallbacks>                                        allocator,
7708                                                   PipelineAllocator & pipelineAllocator,
7709                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7710     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7711     VULKAN_HPP_NODISCARD ResultValue<Pipeline> createGraphicsPipeline(
7712       VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
7713       const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
7714       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7715       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7716 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7717     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
7718               typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
7719     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
7720                          createGraphicsPipelinesUnique(
7721                            VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
7722                            ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
7723                            Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7724                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7725     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
7726               typename PipelineAllocator         = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
7727               typename B                         = PipelineAllocator,
7728               typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
7729                                       int>::type = 0>
7730     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
7731                          createGraphicsPipelinesUnique(
7732                            VULKAN_HPP_NAMESPACE::PipelineCache                                        pipelineCache,
7733                            ArrayProxy<const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
7734                            Optional<const AllocationCallbacks>                                        allocator,
7735                            PipelineAllocator &                                                        pipelineAllocator,
7736                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7737     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7738     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>> createGraphicsPipelineUnique(
7739       VULKAN_HPP_NAMESPACE::PipelineCache                      pipelineCache,
7740       const VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo & createInfo,
7741       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7742       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7743 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7744 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7745 
7746     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7747     VULKAN_HPP_NODISCARD Result
7748                          createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                     pipelineCache,
7749                                                  uint32_t                                                createInfoCount,
7750                                                  const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo * pCreateInfos,
7751                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
7752                                                  VULKAN_HPP_NAMESPACE::Pipeline *                        pPipelines,
7753                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7754 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7755     template <typename PipelineAllocator = std::allocator<Pipeline>,
7756               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7757     VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createComputePipelines(
7758       VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
7759       ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
7760       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7761       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7762     template <typename PipelineAllocator = std::allocator<Pipeline>,
7763               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
7764               typename B                 = PipelineAllocator,
7765               typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
7766     VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>>
7767                          createComputePipelines( VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
7768                                                  ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
7769                                                  Optional<const AllocationCallbacks>                                       allocator,
7770                                                  PipelineAllocator & pipelineAllocator,
7771                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7772     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7773     VULKAN_HPP_NODISCARD ResultValue<Pipeline> createComputePipeline(
7774       VULKAN_HPP_NAMESPACE::PipelineCache                     pipelineCache,
7775       const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
7776       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7777       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7778 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7779     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
7780               typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
7781     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
7782                          createComputePipelinesUnique(
7783                            VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
7784                            ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
7785                            Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7786                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7787     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
7788               typename PipelineAllocator         = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
7789               typename B                         = PipelineAllocator,
7790               typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
7791                                       int>::type = 0>
7792     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
7793                          createComputePipelinesUnique(
7794                            VULKAN_HPP_NAMESPACE::PipelineCache                                       pipelineCache,
7795                            ArrayProxy<const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
7796                            Optional<const AllocationCallbacks>                                       allocator,
7797                            PipelineAllocator &                                                       pipelineAllocator,
7798                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7799     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7800     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>> createComputePipelineUnique(
7801       VULKAN_HPP_NAMESPACE::PipelineCache                     pipelineCache,
7802       const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo,
7803       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7804       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7805 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7806 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7807 
7808     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7809     void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,
7810                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7811                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7812 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7813     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7814     void destroyPipeline( VULKAN_HPP_NAMESPACE::Pipeline pipeline VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7815                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7816                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7817 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7818 
7819     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7820     void destroy( VULKAN_HPP_NAMESPACE::Pipeline                    pipeline,
7821                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7822                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7823 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7824     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7825     void destroy( VULKAN_HPP_NAMESPACE::Pipeline      pipeline,
7826                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7827                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7828 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7829 
7830     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7831     VULKAN_HPP_NODISCARD Result
7832                          createPipelineLayout( const VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo * pCreateInfo,
7833                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
7834                                                VULKAN_HPP_NAMESPACE::PipelineLayout *                 pPipelineLayout,
7835                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7836 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7837     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7838     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::PipelineLayout>::type
7839       createPipelineLayout( const PipelineLayoutCreateInfo &    createInfo,
7840                             Optional<const AllocationCallbacks> allocator
7841                                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7842                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7843 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7844     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7845     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7846       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PipelineLayout, Dispatch>>::type
7847       createPipelineLayoutUnique( const PipelineLayoutCreateInfo &    createInfo,
7848                                   Optional<const AllocationCallbacks> allocator
7849                                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7850                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7851 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7852 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7853 
7854     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7855     void destroyPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayout              pipelineLayout,
7856                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7857                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7858 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7859     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7860     void destroyPipelineLayout(
7861       VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7862       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7863       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7864 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7865 
7866     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7867     void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout              pipelineLayout,
7868                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7869                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7870 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7871     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7872     void destroy( VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout,
7873                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7874                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7875 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7876 
7877     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7878     VULKAN_HPP_NODISCARD Result
7879                          createSampler( const VULKAN_HPP_NAMESPACE::SamplerCreateInfo *   pCreateInfo,
7880                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7881                                         VULKAN_HPP_NAMESPACE::Sampler *                   pSampler,
7882                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7883 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7884     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7885     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Sampler>::type
7886       createSampler( const SamplerCreateInfo &           createInfo,
7887                      Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7888                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7889 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7890     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7891     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7892       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Sampler, Dispatch>>::type
7893       createSamplerUnique( const SamplerCreateInfo &           createInfo,
7894                            Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7895                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7896 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7897 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7898 
7899     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7900     void destroySampler( VULKAN_HPP_NAMESPACE::Sampler                     sampler,
7901                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7902                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7903 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7904     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7905     void destroySampler( VULKAN_HPP_NAMESPACE::Sampler sampler VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7906                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7907                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7908 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7909 
7910     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7911     void destroy( VULKAN_HPP_NAMESPACE::Sampler                     sampler,
7912                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7913                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7914 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7915     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7916     void destroy( VULKAN_HPP_NAMESPACE::Sampler       sampler,
7917                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7918                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7919 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7920 
7921     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7922     VULKAN_HPP_NODISCARD Result createDescriptorSetLayout(
7923       const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
7924       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *           pAllocator,
7925       VULKAN_HPP_NAMESPACE::DescriptorSetLayout *                 pSetLayout,
7926       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7927 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7928     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7929     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>::type
7930       createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo,
7931                                  Optional<const AllocationCallbacks>   allocator
7932                                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7933                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7934 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7935     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7936     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7937       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorSetLayout, Dispatch>>::type
7938       createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo,
7939                                        Optional<const AllocationCallbacks>   allocator
7940                                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7941                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7942 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7943 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7944 
7945     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7946     void destroyDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,
7947                                      const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7948                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
7949       VULKAN_HPP_NOEXCEPT;
7950 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7951     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7952     void destroyDescriptorSetLayout(
7953       VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
7954       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7955       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7956 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7957 
7958     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7959     void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout         descriptorSetLayout,
7960                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7961                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7962 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7963     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7964     void destroy( VULKAN_HPP_NAMESPACE::DescriptorSetLayout descriptorSetLayout,
7965                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7966                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7967 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7968 
7969     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7970     VULKAN_HPP_NODISCARD Result
7971                          createDescriptorPool( const VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo * pCreateInfo,
7972                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
7973                                                VULKAN_HPP_NAMESPACE::DescriptorPool *                 pDescriptorPool,
7974                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7975 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7976     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7977     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorPool>::type
7978       createDescriptorPool( const DescriptorPoolCreateInfo &    createInfo,
7979                             Optional<const AllocationCallbacks> allocator
7980                                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7981                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7982 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
7983     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7984     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
7985       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorPool, Dispatch>>::type
7986       createDescriptorPoolUnique( const DescriptorPoolCreateInfo &    createInfo,
7987                                   Optional<const AllocationCallbacks> allocator
7988                                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
7989                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
7990 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
7991 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
7992 
7993     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7994     void destroyDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,
7995                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
7996                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
7997 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
7998     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
7999     void destroyDescriptorPool(
8000       VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8001       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8002       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8003 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8004 
8005     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8006     void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool              descriptorPool,
8007                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8008                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8009 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8010     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8011     void destroy( VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool,
8012                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8013                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8014 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8015 
8016 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8017     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8018     Result resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool           descriptorPool,
8019                                 VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags,
8020                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8021 #else
8022     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8023     typename ResultValueType<void>::type
8024       resetDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPool           descriptorPool,
8025                            VULKAN_HPP_NAMESPACE::DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8026                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8027 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8028 
8029     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8030     VULKAN_HPP_NODISCARD Result
8031                          allocateDescriptorSets( const VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo * pAllocateInfo,
8032                                                  VULKAN_HPP_NAMESPACE::DescriptorSet *                   pDescriptorSets,
8033                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8034 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8035     template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>,
8036               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8037     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8038       typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type
8039       allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
8040                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8041     template <typename DescriptorSetAllocator = std::allocator<DescriptorSet>,
8042               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8043               typename B                      = DescriptorSetAllocator,
8044               typename std::enable_if<std::is_same<typename B::value_type, DescriptorSet>::value, int>::type = 0>
8045     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8046       typename ResultValueType<std::vector<DescriptorSet, DescriptorSetAllocator>>::type
8047       allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo,
8048                               DescriptorSetAllocator &          descriptorSetAllocator,
8049                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8050 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8051     template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8052               typename DescriptorSetAllocator = std::allocator<UniqueHandle<DescriptorSet, Dispatch>>>
8053     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8054       typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
8055       allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo,
8056                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8057     template <
8058       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8059       typename DescriptorSetAllocator    = std::allocator<UniqueHandle<DescriptorSet, Dispatch>>,
8060       typename B                         = DescriptorSetAllocator,
8061       typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<DescriptorSet, Dispatch>>::value,
8062                               int>::type = 0>
8063     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8064       typename ResultValueType<std::vector<UniqueHandle<DescriptorSet, Dispatch>, DescriptorSetAllocator>>::type
8065       allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo,
8066                                     DescriptorSetAllocator &          descriptorSetAllocator,
8067                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8068 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8069 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8070 
8071     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8072     Result freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,
8073                                uint32_t                                    descriptorSetCount,
8074                                const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
8075                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8076 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8077     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8078     typename ResultValueType<void>::type
8079       freeDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorPool                          descriptorPool,
8080                           ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
8081                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8082 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8083 
8084     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8085     Result free( VULKAN_HPP_NAMESPACE::DescriptorPool        descriptorPool,
8086                  uint32_t                                    descriptorSetCount,
8087                  const VULKAN_HPP_NAMESPACE::DescriptorSet * pDescriptorSets,
8088                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8089 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8090     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8091     typename ResultValueType<void>::type
8092       free( VULKAN_HPP_NAMESPACE::DescriptorPool                          descriptorPool,
8093             ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
8094             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8095 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8096 
8097     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8098     void updateDescriptorSets( uint32_t                                         descriptorWriteCount,
8099                                const VULKAN_HPP_NAMESPACE::WriteDescriptorSet * pDescriptorWrites,
8100                                uint32_t                                         descriptorCopyCount,
8101                                const VULKAN_HPP_NAMESPACE::CopyDescriptorSet *  pDescriptorCopies,
8102                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8103 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8104     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8105     void updateDescriptorSets( ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
8106                                ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const &  descriptorCopies,
8107                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8108 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8109 
8110     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8111     VULKAN_HPP_NODISCARD Result
8112                          createFramebuffer( const VULKAN_HPP_NAMESPACE::FramebufferCreateInfo * pCreateInfo,
8113                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
8114                                             VULKAN_HPP_NAMESPACE::Framebuffer *                 pFramebuffer,
8115                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8116 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8117     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8118     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Framebuffer>::type
8119       createFramebuffer( const FramebufferCreateInfo &       createInfo,
8120                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8121                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8122 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8123     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8124     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8125       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Framebuffer, Dispatch>>::type
8126       createFramebufferUnique( const FramebufferCreateInfo &       createInfo,
8127                                Optional<const AllocationCallbacks> allocator
8128                                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8129                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8130 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8131 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8132 
8133     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8134     void destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,
8135                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8136                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8137 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8138     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8139     void
8140       destroyFramebuffer( VULKAN_HPP_NAMESPACE::Framebuffer framebuffer VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8141                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8142                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8143 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8144 
8145     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8146     void destroy( VULKAN_HPP_NAMESPACE::Framebuffer                 framebuffer,
8147                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8148                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8149 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8150     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8151     void destroy( VULKAN_HPP_NAMESPACE::Framebuffer   framebuffer,
8152                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8153                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8154 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8155 
8156     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8157     VULKAN_HPP_NODISCARD Result
8158                          createRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo * pCreateInfo,
8159                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks *  pAllocator,
8160                                            VULKAN_HPP_NAMESPACE::RenderPass *                 pRenderPass,
8161                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8162 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8163     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8164     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
8165       createRenderPass( const RenderPassCreateInfo &        createInfo,
8166                         Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8167                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8168 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8169     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8170     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8171       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
8172       createRenderPassUnique( const RenderPassCreateInfo &        createInfo,
8173                               Optional<const AllocationCallbacks> allocator
8174                                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8175                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8176 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8177 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8178 
8179     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8180     void destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,
8181                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8182                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8183 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8184     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8185     void
8186       destroyRenderPass( VULKAN_HPP_NAMESPACE::RenderPass renderPass VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8187                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8188                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8189 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8190 
8191     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8192     void destroy( VULKAN_HPP_NAMESPACE::RenderPass                  renderPass,
8193                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8194                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8195 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8196     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8197     void destroy( VULKAN_HPP_NAMESPACE::RenderPass    renderPass,
8198                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8199                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8200 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8201 
8202     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8203     void
8204       getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
8205                                 VULKAN_HPP_NAMESPACE::Extent2D * pGranularity,
8206                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8207 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8208     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8209     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D
8210                          getRenderAreaGranularity( VULKAN_HPP_NAMESPACE::RenderPass renderPass,
8211                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8212 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8213 
8214     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8215     VULKAN_HPP_NODISCARD Result
8216                          createCommandPool( const VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo * pCreateInfo,
8217                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
8218                                             VULKAN_HPP_NAMESPACE::CommandPool *                 pCommandPool,
8219                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8220 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8221     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8222     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::CommandPool>::type
8223       createCommandPool( const CommandPoolCreateInfo &       createInfo,
8224                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8225                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8226 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8227     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8228     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8229       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CommandPool, Dispatch>>::type
8230       createCommandPoolUnique( const CommandPoolCreateInfo &       createInfo,
8231                                Optional<const AllocationCallbacks> allocator
8232                                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8233                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8234 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8235 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8236 
8237     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8238     void destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
8239                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8240                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8241 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8242     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8243     void
8244       destroyCommandPool( VULKAN_HPP_NAMESPACE::CommandPool commandPool VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8245                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8246                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8247 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8248 
8249     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8250     void destroy( VULKAN_HPP_NAMESPACE::CommandPool                 commandPool,
8251                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8252                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8253 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8254     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8255     void destroy( VULKAN_HPP_NAMESPACE::CommandPool   commandPool,
8256                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8257                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8258 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8259 
8260 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
8261     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8262     VULKAN_HPP_NODISCARD Result
8263                          resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
8264                                            VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags,
8265                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8266 #else
8267     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8268     typename ResultValueType<void>::type
8269       resetCommandPool( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
8270                         VULKAN_HPP_NAMESPACE::CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8271                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8272 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8273 
8274     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8275     VULKAN_HPP_NODISCARD Result
8276                          allocateCommandBuffers( const VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo * pAllocateInfo,
8277                                                  VULKAN_HPP_NAMESPACE::CommandBuffer *                   pCommandBuffers,
8278                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8279 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8280     template <typename CommandBufferAllocator = std::allocator<CommandBuffer>,
8281               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8282     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8283       typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type
8284       allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
8285                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8286     template <typename CommandBufferAllocator = std::allocator<CommandBuffer>,
8287               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8288               typename B                      = CommandBufferAllocator,
8289               typename std::enable_if<std::is_same<typename B::value_type, CommandBuffer>::value, int>::type = 0>
8290     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8291       typename ResultValueType<std::vector<CommandBuffer, CommandBufferAllocator>>::type
8292       allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo,
8293                               CommandBufferAllocator &          commandBufferAllocator,
8294                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8295 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8296     template <typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8297               typename CommandBufferAllocator = std::allocator<UniqueHandle<CommandBuffer, Dispatch>>>
8298     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8299       typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
8300       allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo,
8301                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8302     template <
8303       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8304       typename CommandBufferAllocator    = std::allocator<UniqueHandle<CommandBuffer, Dispatch>>,
8305       typename B                         = CommandBufferAllocator,
8306       typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<CommandBuffer, Dispatch>>::value,
8307                               int>::type = 0>
8308     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8309       typename ResultValueType<std::vector<UniqueHandle<CommandBuffer, Dispatch>, CommandBufferAllocator>>::type
8310       allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo,
8311                                     CommandBufferAllocator &          commandBufferAllocator,
8312                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8313 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8314 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8315 
8316     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8317     void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
8318                              uint32_t                                    commandBufferCount,
8319                              const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
8320                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8321 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8322     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8323     void freeCommandBuffers( VULKAN_HPP_NAMESPACE::CommandPool                             commandPool,
8324                              ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
8325                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8326 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8327 
8328     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8329     void free( VULKAN_HPP_NAMESPACE::CommandPool           commandPool,
8330                uint32_t                                    commandBufferCount,
8331                const VULKAN_HPP_NAMESPACE::CommandBuffer * pCommandBuffers,
8332                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8333 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8334     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8335     void free( VULKAN_HPP_NAMESPACE::CommandPool                             commandPool,
8336                ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers,
8337                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8338 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8339 
8340     //=== VK_VERSION_1_1 ===
8341 
8342     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8343     VULKAN_HPP_NODISCARD Result
8344                          bindBufferMemory2( uint32_t                                           bindInfoCount,
8345                                             const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
8346                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8347 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8348     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8349     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
8350       bindBufferMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
8351                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8352 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8353 
8354     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8355     VULKAN_HPP_NODISCARD Result
8356                          bindImageMemory2( uint32_t                                          bindInfoCount,
8357                                            const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
8358                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8359 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8360     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8361     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
8362       bindImageMemory2( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
8363                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8364 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8365 
8366     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8367     void getGroupPeerMemoryFeatures( uint32_t                                       heapIndex,
8368                                      uint32_t                                       localDeviceIndex,
8369                                      uint32_t                                       remoteDeviceIndex,
8370                                      VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
8371                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
8372       VULKAN_HPP_NOEXCEPT;
8373 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8374     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8375     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeatures(
8376       uint32_t         heapIndex,
8377       uint32_t         localDeviceIndex,
8378       uint32_t         remoteDeviceIndex,
8379       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8380 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8381 
8382     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8383     void getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
8384                                       VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,
8385                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
8386       VULKAN_HPP_NOEXCEPT;
8387 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8388     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8389     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2(
8390       const ImageMemoryRequirementsInfo2 & info,
8391       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8392     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8393     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirements2(
8394       const ImageMemoryRequirementsInfo2 & info,
8395       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8396 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8397 
8398     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8399     void getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
8400                                        VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                 pMemoryRequirements,
8401                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
8402       VULKAN_HPP_NOEXCEPT;
8403 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8404     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8405     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2(
8406       const BufferMemoryRequirementsInfo2 & info,
8407       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8408     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8409     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirements2(
8410       const BufferMemoryRequirementsInfo2 & info,
8411       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8412 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8413 
8414     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8415     void getImageSparseMemoryRequirements2(
8416       const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
8417       uint32_t *                                                       pSparseMemoryRequirementCount,
8418       VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,
8419       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8420 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8421     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
8422               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8423     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
8424                          getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info,
8425                                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8426     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
8427               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8428               typename B                                       = SparseImageMemoryRequirements2Allocator,
8429               typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value,
8430                                       int>::type               = 0>
8431     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
8432                          getImageSparseMemoryRequirements2(
8433                            const ImageSparseMemoryRequirementsInfo2 & info,
8434                            SparseImageMemoryRequirements2Allocator &  sparseImageMemoryRequirements2Allocator,
8435                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8436 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8437 
8438     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8439     void trimCommandPool( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,
8440                           VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
8441                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8442 
8443     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8444     void getQueue2( const VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 * pQueueInfo,
8445                     VULKAN_HPP_NAMESPACE::Queue *                  pQueue,
8446                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8447 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8448     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8449     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Queue
8450                          getQueue2( const DeviceQueueInfo2 & queueInfo,
8451                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8452 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8453 
8454     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8455     VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion(
8456       const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
8457       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
8458       VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *                 pYcbcrConversion,
8459       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8460 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8461     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8462     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
8463       createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo,
8464                                     Optional<const AllocationCallbacks>      allocator
8465                                                                              VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8466                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8467 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8468     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8469     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8470       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
8471       createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
8472                                           Optional<const AllocationCallbacks>      allocator
8473                                                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8474                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8475 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8476 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8477 
8478     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8479     void destroySamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
8480                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8481                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
8482       VULKAN_HPP_NOEXCEPT;
8483 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8484     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8485     void destroySamplerYcbcrConversion(
8486       VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8487       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8488       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8489 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8490 
8491     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8492     void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
8493                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8494                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8495 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8496     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8497     void destroy( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
8498                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8499                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8500 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8501 
8502     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8503     VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate(
8504       const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,
8505       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
8506       VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *                 pDescriptorUpdateTemplate,
8507       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8508 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8509     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8510     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8511       typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type
8512       createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo & createInfo,
8513                                       Optional<const AllocationCallbacks>        allocator
8514                                                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8515                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8516 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8517     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8518     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8519       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type
8520       createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo,
8521                                             Optional<const AllocationCallbacks>        allocator
8522                                                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8523                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8524 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8525 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8526 
8527     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8528     void destroyDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
8529                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8530                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
8531       VULKAN_HPP_NOEXCEPT;
8532 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8533     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8534     void destroyDescriptorUpdateTemplate(
8535       VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8536       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8537       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8538 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8539 
8540     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8541     void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
8542                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8543                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8544 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8545     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8546     void destroy( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
8547                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8548                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8549 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8550 
8551     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8552     void updateDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
8553                                           VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
8554                                           const void *                                   pData,
8555                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
8556       VULKAN_HPP_NOEXCEPT;
8557 
8558     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8559     void getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
8560                                         VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,
8561                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
8562       VULKAN_HPP_NOEXCEPT;
8563 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8564     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8565     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupport(
8566       const DescriptorSetLayoutCreateInfo & createInfo,
8567       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8568     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8569     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getDescriptorSetLayoutSupport(
8570       const DescriptorSetLayoutCreateInfo & createInfo,
8571       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8572 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8573 
8574     //=== VK_VERSION_1_2 ===
8575 
8576     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8577     VULKAN_HPP_NODISCARD Result
8578                          createRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
8579                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
8580                                             VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,
8581                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8582 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8583     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8584     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
8585       createRenderPass2( const RenderPassCreateInfo2 &       createInfo,
8586                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8587                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8588 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8589     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8590     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8591       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
8592       createRenderPass2Unique( const RenderPassCreateInfo2 &       createInfo,
8593                                Optional<const AllocationCallbacks> allocator
8594                                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8595                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8596 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8597 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8598 
8599     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8600     void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
8601                          uint32_t                        firstQuery,
8602                          uint32_t                        queryCount,
8603                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8604 
8605     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8606     VULKAN_HPP_NODISCARD Result
8607                          getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
8608                                                    uint64_t *                      pValue,
8609                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8610 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8611     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8612     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type
8613       getSemaphoreCounterValue( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
8614                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8615 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8616 
8617     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8618     VULKAN_HPP_NODISCARD Result
8619                          waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
8620                                          uint64_t                                        timeout,
8621                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8622 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8623     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8624     VULKAN_HPP_NODISCARD Result waitSemaphores( const SemaphoreWaitInfo & waitInfo,
8625                                                 uint64_t                  timeout,
8626                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8627 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8628 
8629     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8630     VULKAN_HPP_NODISCARD Result
8631                          signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,
8632                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8633 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8634     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8635     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
8636       signalSemaphore( const SemaphoreSignalInfo & signalInfo,
8637                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8638 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8639 
8640     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8641     DeviceAddress
8642       getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
8643                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8644 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8645     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8646     DeviceAddress
8647       getBufferAddress( const BufferDeviceAddressInfo & info,
8648                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8649 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8650 
8651     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8652     uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
8653                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
8654       VULKAN_HPP_NOEXCEPT;
8655 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8656     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8657     uint64_t getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info,
8658                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
8659       VULKAN_HPP_NOEXCEPT;
8660 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8661 
8662     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8663     uint64_t getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
8664                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
8665       VULKAN_HPP_NOEXCEPT;
8666 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8667     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8668     uint64_t getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo & info,
8669                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
8670       VULKAN_HPP_NOEXCEPT;
8671 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8672 
8673     //=== VK_KHR_swapchain ===
8674 
8675     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8676     VULKAN_HPP_NODISCARD Result
8677                          createSwapchainKHR( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfo,
8678                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
8679                                              VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchain,
8680                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8681 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8682     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8683     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SwapchainKHR>::type
8684       createSwapchainKHR( const SwapchainCreateInfoKHR &      createInfo,
8685                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8686                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8687 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8688     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8689     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8690       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR, Dispatch>>::type
8691       createSwapchainKHRUnique( const SwapchainCreateInfoKHR &      createInfo,
8692                                 Optional<const AllocationCallbacks> allocator
8693                                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8694                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8695 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8696 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8697 
8698     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8699     void destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,
8700                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8701                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8702 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8703     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8704     void
8705       destroySwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8706                            Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8707                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8708 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8709 
8710     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8711     void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR                swapchain,
8712                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8713                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8714 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8715     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8716     void destroy( VULKAN_HPP_NAMESPACE::SwapchainKHR  swapchain,
8717                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8718                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8719 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8720 
8721     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8722     VULKAN_HPP_NODISCARD Result
8723                          getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
8724                                                 uint32_t *                         pSwapchainImageCount,
8725                                                 VULKAN_HPP_NAMESPACE::Image *      pSwapchainImages,
8726                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8727 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8728     template <typename ImageAllocator = std::allocator<Image>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8729     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Image, ImageAllocator>>::type
8730       getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
8731                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8732     template <typename ImageAllocator = std::allocator<Image>,
8733               typename Dispatch       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8734               typename B              = ImageAllocator,
8735               typename std::enable_if<std::is_same<typename B::value_type, Image>::value, int>::type = 0>
8736     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Image, ImageAllocator>>::type
8737       getSwapchainImagesKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
8738                              ImageAllocator &                   imageAllocator,
8739                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8740 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8741 
8742     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8743     VULKAN_HPP_NODISCARD Result
8744                          acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
8745                                               uint64_t                           timeout,
8746                                               VULKAN_HPP_NAMESPACE::Semaphore    semaphore,
8747                                               VULKAN_HPP_NAMESPACE::Fence        fence,
8748                                               uint32_t *                         pImageIndex,
8749                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8750 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8751     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8752     VULKAN_HPP_NODISCARD ResultValue<uint32_t>
8753                          acquireNextImageKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
8754                                               uint64_t                           timeout,
8755                                               VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8756                                               VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
8757                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8758 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8759 
8760     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8761     VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR(
8762       VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities,
8763       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8764 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8765     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8766     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8767       typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>::type
8768       getGroupPresentCapabilitiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8769 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8770 
8771     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8772     VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR(
8773       VULKAN_HPP_NAMESPACE::SurfaceKHR                       surface,
8774       VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR * pModes,
8775       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8776 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8777     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8778     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8779       typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
8780       getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
8781                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8782 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8783 
8784     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8785     VULKAN_HPP_NODISCARD Result
8786                          acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR * pAcquireInfo,
8787                                                uint32_t *                                            pImageIndex,
8788                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8789 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8790     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8791     VULKAN_HPP_NODISCARD ResultValue<uint32_t>
8792                          acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo,
8793                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8794 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8795 
8796     //=== VK_KHR_display_swapchain ===
8797 
8798     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8799     VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR(
8800       uint32_t                                             swapchainCount,
8801       const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR * pCreateInfos,
8802       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *    pAllocator,
8803       VULKAN_HPP_NAMESPACE::SwapchainKHR *                 pSwapchains,
8804       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8805 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8806     template <typename SwapchainKHRAllocator = std::allocator<SwapchainKHR>,
8807               typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8808     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8809       typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type
8810       createSharedSwapchainsKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
8811                                  Optional<const AllocationCallbacks>                                    allocator
8812                                                                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8813                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8814     template <typename SwapchainKHRAllocator = std::allocator<SwapchainKHR>,
8815               typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8816               typename B                     = SwapchainKHRAllocator,
8817               typename std::enable_if<std::is_same<typename B::value_type, SwapchainKHR>::value, int>::type = 0>
8818     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8819       typename ResultValueType<std::vector<SwapchainKHR, SwapchainKHRAllocator>>::type
8820       createSharedSwapchainsKHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
8821                                  Optional<const AllocationCallbacks>                                    allocator,
8822                                  SwapchainKHRAllocator & swapchainKHRAllocator,
8823                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8824     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8825     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<SwapchainKHR>::type createSharedSwapchainKHR(
8826       const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
8827       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8828       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8829 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
8830     template <typename Dispatch              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8831               typename SwapchainKHRAllocator = std::allocator<UniqueHandle<SwapchainKHR, Dispatch>>>
8832     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8833       typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
8834       createSharedSwapchainsKHRUnique(
8835         ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
8836         Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8837         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8838     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8839               typename SwapchainKHRAllocator     = std::allocator<UniqueHandle<SwapchainKHR, Dispatch>>,
8840               typename B                         = SwapchainKHRAllocator,
8841               typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<SwapchainKHR, Dispatch>>::value,
8842                                       int>::type = 0>
8843     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8844       typename ResultValueType<std::vector<UniqueHandle<SwapchainKHR, Dispatch>, SwapchainKHRAllocator>>::type
8845       createSharedSwapchainsKHRUnique(
8846         ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
8847         Optional<const AllocationCallbacks>                                    allocator,
8848         SwapchainKHRAllocator &                                                swapchainKHRAllocator,
8849         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8850     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8851     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<UniqueHandle<SwapchainKHR, Dispatch>>::type
8852       createSharedSwapchainKHRUnique( const VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR & createInfo,
8853                                       Optional<const AllocationCallbacks>                  allocator
8854                                                                                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8855                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8856 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8857 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8858 
8859     //=== VK_EXT_debug_marker ===
8860 
8861     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8862     VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT(
8863       const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT * pTagInfo,
8864       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8865 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8866     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8867     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
8868       debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo,
8869                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8870 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8871 
8872     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8873     VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT(
8874       const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT * pNameInfo,
8875       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8876 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8877     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8878     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
8879       debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo,
8880                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8881 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8882 
8883 #if defined( VK_ENABLE_BETA_EXTENSIONS )
8884     //=== VK_KHR_video_queue ===
8885 
8886     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8887     VULKAN_HPP_NODISCARD Result
8888                          createVideoSessionKHR( const VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR * pCreateInfo,
8889                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
8890                                                 VULKAN_HPP_NAMESPACE::VideoSessionKHR *                 pVideoSession,
8891                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8892 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8893     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8894     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionKHR>::type
8895       createVideoSessionKHR( const VideoSessionCreateInfoKHR &   createInfo,
8896                              Optional<const AllocationCallbacks> allocator
8897                                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8898                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8899 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
8900     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8901     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8902       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionKHR, Dispatch>>::type
8903       createVideoSessionKHRUnique( const VideoSessionCreateInfoKHR &   createInfo,
8904                                    Optional<const AllocationCallbacks> allocator
8905                                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8906                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8907 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8908 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8909 
8910     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8911     void
8912       destroyVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,
8913                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8914                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8915 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8916     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8917     void destroyVideoSessionKHR(
8918       VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
8919       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8920       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8921 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8922 
8923     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8924     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR             videoSession,
8925                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
8926                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8927 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8928     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8929     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
8930                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8931                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8932 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8933 
8934     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8935     VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR(
8936       VULKAN_HPP_NAMESPACE::VideoSessionKHR               videoSession,
8937       uint32_t *                                          pVideoSessionMemoryRequirementsCount,
8938       VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR * pVideoSessionMemoryRequirements,
8939       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8940 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8941     template <typename VideoGetMemoryPropertiesKHRAllocator = std::allocator<VideoGetMemoryPropertiesKHR>,
8942               typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8943     VULKAN_HPP_NODISCARD
8944       typename ResultValueType<std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator>>::type
8945       getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession,
8946                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8947     template <
8948       typename VideoGetMemoryPropertiesKHRAllocator = std::allocator<VideoGetMemoryPropertiesKHR>,
8949       typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
8950       typename B                                    = VideoGetMemoryPropertiesKHRAllocator,
8951       typename std::enable_if<std::is_same<typename B::value_type, VideoGetMemoryPropertiesKHR>::value, int>::type = 0>
8952     VULKAN_HPP_NODISCARD
8953       typename ResultValueType<std::vector<VideoGetMemoryPropertiesKHR, VideoGetMemoryPropertiesKHRAllocator>>::type
8954       getVideoSessionMemoryRequirementsKHR( VULKAN_HPP_NAMESPACE::VideoSessionKHR  videoSession,
8955                                             VideoGetMemoryPropertiesKHRAllocator & videoGetMemoryPropertiesKHRAllocator,
8956                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8957 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8958 
8959     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8960     VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR(
8961       VULKAN_HPP_NAMESPACE::VideoSessionKHR            videoSession,
8962       uint32_t                                         videoSessionBindMemoryCount,
8963       const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR * pVideoSessionBindMemories,
8964       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8965 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8966     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8967     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindVideoSessionMemoryKHR(
8968       VULKAN_HPP_NAMESPACE::VideoSessionKHR                              videoSession,
8969       ArrayProxy<const VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR> const & videoSessionBindMemories,
8970       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8971 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8972 
8973     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8974     VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR(
8975       const VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR * pCreateInfo,
8976       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                 pAllocator,
8977       VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR *                 pVideoSessionParameters,
8978       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
8979 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
8980     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8981     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
8982       typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>::type
8983       createVideoSessionParametersKHR( const VideoSessionParametersCreateInfoKHR & createInfo,
8984                                        Optional<const AllocationCallbacks>         allocator
8985                                                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8986                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8987 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
8988     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8989     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
8990       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR, Dispatch>>::type
8991       createVideoSessionParametersKHRUnique( const VideoSessionParametersCreateInfoKHR & createInfo,
8992                                              Optional<const AllocationCallbacks>         allocator
8993                                                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
8994                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
8995 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
8996 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
8997 
8998     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
8999     VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR(
9000       VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR                   videoSessionParameters,
9001       const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR * pUpdateInfo,
9002       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9003 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9004     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9005     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9006       updateVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
9007                                        const VideoSessionParametersUpdateInfoKHR &     updateInfo,
9008                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9009 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9010 
9011     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9012     void destroyVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,
9013                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9014                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9015       VULKAN_HPP_NOEXCEPT;
9016 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9017     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9018     void destroyVideoSessionParametersKHR(
9019       VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
9020       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9021       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9022 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9023 
9024     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9025     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR   videoSessionParameters,
9026                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9027                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9028 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9029     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9030     void destroy( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters,
9031                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9032                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9033 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9034 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
9035 
9036     //=== VK_NVX_binary_import ===
9037 
9038     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9039     VULKAN_HPP_NODISCARD Result
9040                          createCuModuleNVX( const VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX * pCreateInfo,
9041                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
9042                                             VULKAN_HPP_NAMESPACE::CuModuleNVX *                 pModule,
9043                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9044 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9045     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9046     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::CuModuleNVX>::type
9047       createCuModuleNVX( const CuModuleCreateInfoNVX &       createInfo,
9048                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9049                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9050 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9051     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9052     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9053       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuModuleNVX, Dispatch>>::type
9054       createCuModuleNVXUnique( const CuModuleCreateInfoNVX &       createInfo,
9055                                Optional<const AllocationCallbacks> allocator
9056                                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9057                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9058 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9059 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9060 
9061     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9062     VULKAN_HPP_NODISCARD Result
9063                          createCuFunctionNVX( const VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX * pCreateInfo,
9064                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
9065                                               VULKAN_HPP_NAMESPACE::CuFunctionNVX *                 pFunction,
9066                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9067 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9068     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9069     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::CuFunctionNVX>::type
9070       createCuFunctionNVX( const CuFunctionCreateInfoNVX &     createInfo,
9071                            Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9072                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9073 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9074     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9075     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9076       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::CuFunctionNVX, Dispatch>>::type
9077       createCuFunctionNVXUnique( const CuFunctionCreateInfoNVX &     createInfo,
9078                                  Optional<const AllocationCallbacks> allocator
9079                                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9080                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9081 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9082 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9083 
9084     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9085     void destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,
9086                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9087                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9088 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9089     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9090     void
9091       destroyCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleNVX   module,
9092                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9093                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9094 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9095 
9096     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9097     void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX                 module,
9098                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9099                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9100 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9101     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9102     void destroy( VULKAN_HPP_NAMESPACE::CuModuleNVX   module,
9103                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9104                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9105 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9106 
9107     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9108     void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,
9109                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9110                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9111 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9112     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9113     void destroyCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionNVX function,
9114                                Optional<const AllocationCallbacks> allocator
9115                                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9116                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9117 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9118 
9119     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9120     void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX               function,
9121                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9122                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9123 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9124     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9125     void destroy( VULKAN_HPP_NAMESPACE::CuFunctionNVX function,
9126                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9127                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9128 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9129 
9130     //=== VK_NVX_image_view_handle ===
9131 
9132     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9133     uint32_t
9134       getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX * pInfo,
9135                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9136 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9137     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9138     uint32_t
9139       getImageViewHandleNVX( const ImageViewHandleInfoNVX & info,
9140                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9141 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9142 
9143     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9144     VULKAN_HPP_NODISCARD Result
9145                          getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView                       imageView,
9146                                                  VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX * pProperties,
9147                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9148 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9149     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9150     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9151       typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>::type
9152       getImageViewAddressNVX( VULKAN_HPP_NAMESPACE::ImageView imageView,
9153                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9154 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9155 
9156     //=== VK_AMD_shader_info ===
9157 
9158     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9159     VULKAN_HPP_NODISCARD Result
9160                          getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
9161                                            VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
9162                                            VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
9163                                            size_t *                                  pInfoSize,
9164                                            void *                                    pInfo,
9165                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9166 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9167     template <typename Uint8_tAllocator = std::allocator<uint8_t>,
9168               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9169     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
9170       getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
9171                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
9172                         VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
9173                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9174     template <typename Uint8_tAllocator = std::allocator<uint8_t>,
9175               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9176               typename B                = Uint8_tAllocator,
9177               typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
9178     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
9179       getShaderInfoAMD( VULKAN_HPP_NAMESPACE::Pipeline            pipeline,
9180                         VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
9181                         VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD   infoType,
9182                         Uint8_tAllocator &                        uint8_tAllocator,
9183                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9184 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9185 
9186 #if defined( VK_USE_PLATFORM_WIN32_KHR )
9187     //=== VK_NV_external_memory_win32 ===
9188 
9189     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9190     VULKAN_HPP_NODISCARD Result
9191                          getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,
9192                                                  VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
9193                                                  HANDLE *                                              pHandle,
9194                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9195 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9196     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9197     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
9198       getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::DeviceMemory                    memory,
9199                               VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType,
9200                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9201 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9202 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
9203 
9204     //=== VK_KHR_device_group ===
9205 
9206     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9207     void getGroupPeerMemoryFeaturesKHR( uint32_t                                       heapIndex,
9208                                         uint32_t                                       localDeviceIndex,
9209                                         uint32_t                                       remoteDeviceIndex,
9210                                         VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags * pPeerMemoryFeatures,
9211                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9212       VULKAN_HPP_NOEXCEPT;
9213 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9214     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9215     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR(
9216       uint32_t         heapIndex,
9217       uint32_t         localDeviceIndex,
9218       uint32_t         remoteDeviceIndex,
9219       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9220 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9221 
9222     //=== VK_KHR_maintenance1 ===
9223 
9224     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9225     void trimCommandPoolKHR( VULKAN_HPP_NAMESPACE::CommandPool          commandPool,
9226                              VULKAN_HPP_NAMESPACE::CommandPoolTrimFlags flags,
9227                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9228 
9229 #if defined( VK_USE_PLATFORM_WIN32_KHR )
9230     //=== VK_KHR_external_memory_win32 ===
9231 
9232     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9233     VULKAN_HPP_NODISCARD Result
9234                          getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo,
9235                                                   HANDLE *                                                  pHandle,
9236                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9237 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9238     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9239     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
9240       getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo,
9241                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9242 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9243 
9244     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9245     VULKAN_HPP_NODISCARD Result getMemoryWin32HandlePropertiesKHR(
9246       VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
9247       HANDLE                                                 handle,
9248       VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties,
9249       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9250 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9251     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9252     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9253       typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>::type
9254       getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
9255                                          HANDLE                                                 handle,
9256                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9257 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9258 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
9259 
9260     //=== VK_KHR_external_memory_fd ===
9261 
9262     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9263     VULKAN_HPP_NODISCARD Result
9264                          getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR * pGetFdInfo,
9265                                          int *                                            pFd,
9266                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9267 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9268     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9269     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<int>::type
9270       getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo,
9271                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9272 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9273 
9274     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9275     VULKAN_HPP_NODISCARD Result
9276                          getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
9277                                                    int                                                    fd,
9278                                                    VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR *          pMemoryFdProperties,
9279                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9280 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9281     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9282     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>::type
9283       getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
9284                                 int                                                    fd,
9285                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9286 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9287 
9288 #if defined( VK_USE_PLATFORM_WIN32_KHR )
9289     //=== VK_KHR_external_semaphore_win32 ===
9290 
9291     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9292     VULKAN_HPP_NODISCARD Result importSemaphoreWin32HandleKHR(
9293       const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo,
9294       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9295 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9296     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9297     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9298       importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo,
9299                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9300 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9301 
9302     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9303     VULKAN_HPP_NODISCARD Result getSemaphoreWin32HandleKHR(
9304       const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,
9305       HANDLE *                                                     pHandle,
9306       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9307 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9308     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9309     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
9310       getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo,
9311                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9312 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9313 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
9314 
9315     //=== VK_KHR_external_semaphore_fd ===
9316 
9317     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9318     VULKAN_HPP_NODISCARD Result
9319                          importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo,
9320                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9321 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9322     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9323     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9324       importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo,
9325                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9326 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9327 
9328     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9329     VULKAN_HPP_NODISCARD Result
9330                          getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR * pGetFdInfo,
9331                                             int *                                               pFd,
9332                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9333 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9334     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9335     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<int>::type
9336       getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo,
9337                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9338 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9339 
9340     //=== VK_KHR_descriptor_update_template ===
9341 
9342     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9343     VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR(
9344       const VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo * pCreateInfo,
9345       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
9346       VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate *                 pDescriptorUpdateTemplate,
9347       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9348 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9349     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9350     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9351       typename ResultValueType<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>::type
9352       createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo,
9353                                          Optional<const AllocationCallbacks>        allocator
9354                                                                                     VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9355                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9356 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9357     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9358     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9359       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate, Dispatch>>::type
9360       createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo,
9361                                                Optional<const AllocationCallbacks>        allocator
9362                                                                                           VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9363                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9364 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9365 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9366 
9367     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9368     void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate    descriptorUpdateTemplate,
9369                                              const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9370                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9371       VULKAN_HPP_NOEXCEPT;
9372 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9373     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9374     void destroyDescriptorUpdateTemplateKHR(
9375       VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9376       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9377       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9378 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9379 
9380     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9381     void updateDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorSet            descriptorSet,
9382                                              VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
9383                                              const void *                                   pData,
9384                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9385       VULKAN_HPP_NOEXCEPT;
9386 
9387     //=== VK_EXT_display_control ===
9388 
9389     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9390     VULKAN_HPP_NODISCARD Result
9391                          displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
9392                                                  const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT * pDisplayPowerInfo,
9393                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9394 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9395     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9396     typename ResultValueType<void>::type
9397       displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
9398                               const DisplayPowerInfoEXT &      displayPowerInfo,
9399                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9400 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9401 
9402     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9403     VULKAN_HPP_NODISCARD Result
9404                          registerEventEXT( const VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT *  pDeviceEventInfo,
9405                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9406                                            VULKAN_HPP_NAMESPACE::Fence *                     pFence,
9407                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9408 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9409     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9410     typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type
9411       registerEventEXT( const DeviceEventInfoEXT &          deviceEventInfo,
9412                         Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9413                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9414 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9415     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9416     VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
9417       registerEventEXTUnique( const DeviceEventInfoEXT &          deviceEventInfo,
9418                               Optional<const AllocationCallbacks> allocator
9419                                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9420                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9421 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9422 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9423 
9424     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9425     VULKAN_HPP_NODISCARD Result
9426                          registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
9427                                                   const VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT * pDisplayEventInfo,
9428                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9429                                                   VULKAN_HPP_NAMESPACE::Fence *                     pFence,
9430                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9431 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9432     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9433     typename ResultValueType<VULKAN_HPP_NAMESPACE::Fence>::type registerDisplayEventEXT(
9434       VULKAN_HPP_NAMESPACE::DisplayKHR    display,
9435       const DisplayEventInfoEXT &         displayEventInfo,
9436       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9437       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9438 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9439     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9440     VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Fence, Dispatch>>::type
9441       registerDisplayEventEXTUnique( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
9442                                      const DisplayEventInfoEXT &         displayEventInfo,
9443                                      Optional<const AllocationCallbacks> allocator
9444                                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9445                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9446 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9447 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9448 
9449     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9450     VULKAN_HPP_NODISCARD Result
9451                          getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,
9452                                                  VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
9453                                                  uint64_t *                                      pCounterValue,
9454                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9455 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9456     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9457     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type
9458       getSwapchainCounterEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR              swapchain,
9459                               VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter,
9460                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9461 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9462 
9463     //=== VK_GOOGLE_display_timing ===
9464 
9465     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9466     VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE(
9467       VULKAN_HPP_NAMESPACE::SwapchainKHR                 swapchain,
9468       VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE * pDisplayTimingProperties,
9469       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9470 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9471     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9472     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9473       typename ResultValueType<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>::type
9474       getRefreshCycleDurationGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
9475                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9476 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9477 
9478     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9479     VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE(
9480       VULKAN_HPP_NAMESPACE::SwapchainKHR                   swapchain,
9481       uint32_t *                                           pPresentationTimingCount,
9482       VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE * pPresentationTimings,
9483       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9484 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9485     template <typename PastPresentationTimingGOOGLEAllocator = std::allocator<PastPresentationTimingGOOGLE>,
9486               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9487     VULKAN_HPP_NODISCARD
9488       typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
9489       getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
9490                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9491     template <
9492       typename PastPresentationTimingGOOGLEAllocator = std::allocator<PastPresentationTimingGOOGLE>,
9493       typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9494       typename B                                     = PastPresentationTimingGOOGLEAllocator,
9495       typename std::enable_if<std::is_same<typename B::value_type, PastPresentationTimingGOOGLE>::value, int>::type = 0>
9496     VULKAN_HPP_NODISCARD
9497       typename ResultValueType<std::vector<PastPresentationTimingGOOGLE, PastPresentationTimingGOOGLEAllocator>>::type
9498       getPastPresentationTimingGOOGLE( VULKAN_HPP_NAMESPACE::SwapchainKHR      swapchain,
9499                                        PastPresentationTimingGOOGLEAllocator & pastPresentationTimingGOOGLEAllocator,
9500                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9501 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9502 
9503     //=== VK_EXT_hdr_metadata ===
9504 
9505     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9506     void setHdrMetadataEXT( uint32_t                                     swapchainCount,
9507                             const VULKAN_HPP_NAMESPACE::SwapchainKHR *   pSwapchains,
9508                             const VULKAN_HPP_NAMESPACE::HdrMetadataEXT * pMetadata,
9509                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9510 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9511     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9512     void setHdrMetadataEXT( ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const &   swapchains,
9513                             ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata,
9514                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9515       VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
9516 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9517 
9518     //=== VK_KHR_create_renderpass2 ===
9519 
9520     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9521     VULKAN_HPP_NODISCARD Result
9522                          createRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 * pCreateInfo,
9523                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
9524                                                VULKAN_HPP_NAMESPACE::RenderPass *                  pRenderPass,
9525                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9526 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9527     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9528     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::RenderPass>::type
9529       createRenderPass2KHR( const RenderPassCreateInfo2 &       createInfo,
9530                             Optional<const AllocationCallbacks> allocator
9531                                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9532                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9533 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9534     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9535     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9536       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::RenderPass, Dispatch>>::type
9537       createRenderPass2KHRUnique( const RenderPassCreateInfo2 &       createInfo,
9538                                   Optional<const AllocationCallbacks> allocator
9539                                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9540                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9541 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9542 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9543 
9544     //=== VK_KHR_shared_presentable_image ===
9545 
9546 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
9547     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9548     VULKAN_HPP_NODISCARD Result
9549                          getSwapchainStatusKHR( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
9550                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9551 #else
9552     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9553     VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR(
9554       VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9555 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9556 
9557 #if defined( VK_USE_PLATFORM_WIN32_KHR )
9558     //=== VK_KHR_external_fence_win32 ===
9559 
9560     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9561     VULKAN_HPP_NODISCARD Result importFenceWin32HandleKHR(
9562       const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo,
9563       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9564 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9565     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9566     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9567       importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo,
9568                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9569 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9570 
9571     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9572     VULKAN_HPP_NODISCARD Result
9573                          getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo,
9574                                                  HANDLE *                                                 pHandle,
9575                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9576 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9577     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9578     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<HANDLE>::type
9579       getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo,
9580                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9581 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9582 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
9583 
9584     //=== VK_KHR_external_fence_fd ===
9585 
9586     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9587     VULKAN_HPP_NODISCARD Result
9588                          importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR * pImportFenceFdInfo,
9589                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9590 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9591     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9592     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9593       importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo,
9594                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9595 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9596 
9597     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9598     VULKAN_HPP_NODISCARD Result
9599                          getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR * pGetFdInfo,
9600                                         int *                                           pFd,
9601                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9602 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9603     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9604     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<int>::type
9605       getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo,
9606                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9607 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9608 
9609     //=== VK_KHR_performance_query ===
9610 
9611     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9612     VULKAN_HPP_NODISCARD Result
9613                          acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR * pInfo,
9614                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9615 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9616     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9617     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9618       acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info,
9619                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9620 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9621 
9622     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9623     void
9624       releaseProfilingLockKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9625 
9626     //=== VK_EXT_debug_utils ===
9627 
9628     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9629     VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT(
9630       const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * pNameInfo,
9631       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9632 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9633     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9634     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9635       setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo,
9636                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9637 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9638 
9639     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9640     VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT(
9641       const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT * pTagInfo,
9642       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9643 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9644     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9645     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9646       setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo,
9647                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9648 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9649 
9650 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
9651     //=== VK_ANDROID_external_memory_android_hardware_buffer ===
9652 
9653     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9654     VULKAN_HPP_NODISCARD Result getAndroidHardwareBufferPropertiesANDROID(
9655       const struct AHardwareBuffer *                                 buffer,
9656       VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID * pProperties,
9657       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9658 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9659     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9660     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9661       typename ResultValueType<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>::type
9662       getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer,
9663                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9664     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9665     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
9666       getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer,
9667                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9668 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9669 
9670     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9671     VULKAN_HPP_NODISCARD Result getMemoryAndroidHardwareBufferANDROID(
9672       const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
9673       struct AHardwareBuffer **                                               pBuffer,
9674       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9675 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9676     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9677     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<struct AHardwareBuffer *>::type
9678       getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info,
9679                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9680 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9681 #endif   /*VK_USE_PLATFORM_ANDROID_KHR*/
9682 
9683     //=== VK_KHR_get_memory_requirements2 ===
9684 
9685     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9686     void getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 * pInfo,
9687                                          VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                pMemoryRequirements,
9688                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9689       VULKAN_HPP_NOEXCEPT;
9690 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9691     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9692     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getImageMemoryRequirements2KHR(
9693       const ImageMemoryRequirementsInfo2 & info,
9694       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9695     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9696     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getImageMemoryRequirements2KHR(
9697       const ImageMemoryRequirementsInfo2 & info,
9698       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9699 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9700 
9701     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9702     void getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 * pInfo,
9703                                           VULKAN_HPP_NAMESPACE::MemoryRequirements2 * pMemoryRequirements,
9704                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9705       VULKAN_HPP_NOEXCEPT;
9706 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9707     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9708     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getBufferMemoryRequirements2KHR(
9709       const BufferMemoryRequirementsInfo2 & info,
9710       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9711     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9712     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getBufferMemoryRequirements2KHR(
9713       const BufferMemoryRequirementsInfo2 & info,
9714       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9715 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9716 
9717     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9718     void getImageSparseMemoryRequirements2KHR(
9719       const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 * pInfo,
9720       uint32_t *                                                       pSparseMemoryRequirementCount,
9721       VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 *           pSparseMemoryRequirements,
9722       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9723 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9724     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
9725               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9726     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
9727                          getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info,
9728                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9729     template <typename SparseImageMemoryRequirements2Allocator = std::allocator<SparseImageMemoryRequirements2>,
9730               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
9731               typename B                                       = SparseImageMemoryRequirements2Allocator,
9732               typename std::enable_if<std::is_same<typename B::value_type, SparseImageMemoryRequirements2>::value,
9733                                       int>::type               = 0>
9734     VULKAN_HPP_NODISCARD std::vector<SparseImageMemoryRequirements2, SparseImageMemoryRequirements2Allocator>
9735                          getImageSparseMemoryRequirements2KHR(
9736                            const ImageSparseMemoryRequirementsInfo2 & info,
9737                            SparseImageMemoryRequirements2Allocator &  sparseImageMemoryRequirements2Allocator,
9738                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9739 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9740 
9741     //=== VK_KHR_acceleration_structure ===
9742 
9743     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9744     VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR(
9745       const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR * pCreateInfo,
9746       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
9747       VULKAN_HPP_NAMESPACE::AccelerationStructureKHR *                 pAccelerationStructure,
9748       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9749 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9750     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9751     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
9752       typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>::type
9753       createAccelerationStructureKHR( const AccelerationStructureCreateInfoKHR & createInfo,
9754                                       Optional<const AllocationCallbacks>        allocator
9755                                                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9756                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9757 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9758     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9759     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9760       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR, Dispatch>>::type
9761       createAccelerationStructureKHRUnique( const AccelerationStructureCreateInfoKHR & createInfo,
9762                                             Optional<const AllocationCallbacks>        allocator
9763                                                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9764                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9765 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9766 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9767 
9768     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9769     void destroyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,
9770                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9771                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9772       VULKAN_HPP_NOEXCEPT;
9773 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9774     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9775     void destroyAccelerationStructureKHR(
9776       VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9777       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9778       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9779 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9780 
9781     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9782     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR    accelerationStructure,
9783                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9784                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9785 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9786     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9787     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure,
9788                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9789                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9790 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9791 
9792     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9793     VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR(
9794       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                   deferredOperation,
9795       uint32_t                                                                     infoCount,
9796       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR *      pInfos,
9797       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos,
9798       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9799 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9800     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9801     Result buildAccelerationStructuresKHR(
9802       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                                     deferredOperation,
9803       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const &      infos,
9804       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos,
9805       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
9806 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9807 
9808     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9809     VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR(
9810       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                     deferredOperation,
9811       const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR * pInfo,
9812       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9813 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9814     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9815     VULKAN_HPP_NODISCARD Result
9816                          copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
9817                                                        const CopyAccelerationStructureInfoKHR &   info,
9818                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9819 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9820 
9821     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9822     VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR(
9823       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
9824       const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR * pInfo,
9825       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9826 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9827     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9828     VULKAN_HPP_NODISCARD Result
9829                          copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR       deferredOperation,
9830                                                                const CopyAccelerationStructureToMemoryInfoKHR & info,
9831                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9832 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9833 
9834     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9835     VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR(
9836       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                             deferredOperation,
9837       const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR * pInfo,
9838       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9839 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9840     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9841     VULKAN_HPP_NODISCARD Result
9842                          copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR       deferredOperation,
9843                                                                const CopyMemoryToAccelerationStructureInfoKHR & info,
9844                                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9845 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9846 
9847     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9848     VULKAN_HPP_NODISCARD Result writeAccelerationStructuresPropertiesKHR(
9849       uint32_t                                               accelerationStructureCount,
9850       const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * pAccelerationStructures,
9851       VULKAN_HPP_NAMESPACE::QueryType                        queryType,
9852       size_t                                                 dataSize,
9853       void *                                                 pData,
9854       size_t                                                 stride,
9855       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9856 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9857     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9858     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9859       writeAccelerationStructuresPropertiesKHR(
9860         ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
9861         VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
9862         ArrayProxy<T> const &                                                    data,
9863         size_t                                                                   stride,
9864         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9865     template <typename T,
9866               typename Allocator = std::allocator<T>,
9867               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9868     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
9869       writeAccelerationStructuresPropertiesKHR(
9870         ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
9871         VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
9872         size_t                                                                   dataSize,
9873         size_t                                                                   stride,
9874         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9875     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9876     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type writeAccelerationStructuresPropertyKHR(
9877       ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
9878       VULKAN_HPP_NAMESPACE::QueryType                                          queryType,
9879       size_t                                                                   stride,
9880       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9881 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9882 
9883     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9884     DeviceAddress getAccelerationStructureAddressKHR(
9885       const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR * pInfo,
9886       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9887 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9888     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9889     DeviceAddress getAccelerationStructureAddressKHR(
9890       const AccelerationStructureDeviceAddressInfoKHR & info,
9891       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9892 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9893 
9894     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9895     void getAccelerationStructureCompatibilityKHR(
9896       const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR * pVersionInfo,
9897       VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR *     pCompatibility,
9898       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9899 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9900     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9901     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureCompatibilityKHR
9902                          getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR & versionInfo,
9903                                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9904       VULKAN_HPP_NOEXCEPT;
9905 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9906 
9907     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9908     void getAccelerationStructureBuildSizesKHR(
9909       VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR                 buildType,
9910       const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
9911       const uint32_t *                                                        pMaxPrimitiveCounts,
9912       VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR *          pSizeInfo,
9913       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9914 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9915     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9916     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR
9917                          getAccelerationStructureBuildSizesKHR(
9918                            VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
9919                            const AccelerationStructureBuildGeometryInfoKHR &       buildInfo,
9920                            ArrayProxy<const uint32_t> const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9921                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS;
9922 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9923 
9924     //=== VK_KHR_sampler_ycbcr_conversion ===
9925 
9926     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9927     VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR(
9928       const VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo * pCreateInfo,
9929       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
9930       VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion *                 pYcbcrConversion,
9931       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9932 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9933     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9934     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>::type
9935       createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo,
9936                                        Optional<const AllocationCallbacks>      allocator
9937                                                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9938                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9939 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
9940     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9941     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
9942       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion, Dispatch>>::type
9943       createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo,
9944                                              Optional<const AllocationCallbacks>      allocator
9945                                                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9946                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9947 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
9948 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9949 
9950     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9951     void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion      ycbcrConversion,
9952                                            const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
9953                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
9954       VULKAN_HPP_NOEXCEPT;
9955 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9956     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9957     void destroySamplerYcbcrConversionKHR(
9958       VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
9959       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
9960       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9961 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9962 
9963     //=== VK_KHR_bind_memory2 ===
9964 
9965     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9966     VULKAN_HPP_NODISCARD Result
9967                          bindBufferMemory2KHR( uint32_t                                           bindInfoCount,
9968                                                const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo * pBindInfos,
9969                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9970 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9971     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9972     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9973       bindBufferMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos,
9974                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9975 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9976 
9977     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9978     VULKAN_HPP_NODISCARD Result
9979                          bindImageMemory2KHR( uint32_t                                          bindInfoCount,
9980                                               const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo * pBindInfos,
9981                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9982 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9983     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9984     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
9985       bindImageMemory2KHR( ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos,
9986                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
9987 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
9988 
9989     //=== VK_EXT_image_drm_format_modifier ===
9990 
9991     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9992     VULKAN_HPP_NODISCARD Result getImageDrmFormatModifierPropertiesEXT(
9993       VULKAN_HPP_NAMESPACE::Image                                 image,
9994       VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT * pProperties,
9995       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
9996 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
9997     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
9998     typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>::type
9999       getImageDrmFormatModifierPropertiesEXT( VULKAN_HPP_NAMESPACE::Image image,
10000                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10001 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10002 
10003     //=== VK_EXT_validation_cache ===
10004 
10005     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10006     VULKAN_HPP_NODISCARD Result
10007                          createValidationCacheEXT( const VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT * pCreateInfo,
10008                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
10009                                                    VULKAN_HPP_NAMESPACE::ValidationCacheEXT *                 pValidationCache,
10010                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10011 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10012     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10013     typename ResultValueType<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>::type createValidationCacheEXT(
10014       const ValidationCacheCreateInfoEXT & createInfo,
10015       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10016       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10017 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10018     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10019     VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::ValidationCacheEXT, Dispatch>>::type
10020       createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo,
10021                                       Optional<const AllocationCallbacks>  allocator
10022                                                                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10023                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10024 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10025 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10026 
10027     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10028     void destroyValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,
10029                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10030                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10031       VULKAN_HPP_NOEXCEPT;
10032 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10033     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10034     void destroyValidationCacheEXT(
10035       VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10036       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10037       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10038 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10039 
10040     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10041     void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT          validationCache,
10042                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10043                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10044 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10045     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10046     void destroy( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
10047                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10048                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10049 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10050 
10051     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10052     VULKAN_HPP_NODISCARD Result
10053                          mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT         dstCache,
10054                                                    uint32_t                                         srcCacheCount,
10055                                                    const VULKAN_HPP_NAMESPACE::ValidationCacheEXT * pSrcCaches,
10056                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10057 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10058     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10059     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10060       mergeValidationCachesEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT                           dstCache,
10061                                 ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches,
10062                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10063 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10064 
10065     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10066     VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT(
10067       VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
10068       size_t *                                 pDataSize,
10069       void *                                   pData,
10070       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10071 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10072     template <typename Uint8_tAllocator = std::allocator<uint8_t>,
10073               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10074     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
10075       getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
10076                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10077     template <typename Uint8_tAllocator = std::allocator<uint8_t>,
10078               typename Dispatch         = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10079               typename B                = Uint8_tAllocator,
10080               typename std::enable_if<std::is_same<typename B::value_type, uint8_t>::value, int>::type = 0>
10081     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<uint8_t, Uint8_tAllocator>>::type
10082       getValidationCacheDataEXT( VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache,
10083                                  Uint8_tAllocator &                       uint8_tAllocator,
10084                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10085 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10086 
10087     //=== VK_NV_ray_tracing ===
10088 
10089     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10090     VULKAN_HPP_NODISCARD Result createAccelerationStructureNV(
10091       const VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV * pCreateInfo,
10092       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
10093       VULKAN_HPP_NAMESPACE::AccelerationStructureNV *                 pAccelerationStructure,
10094       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10095 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10096     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10097     typename ResultValueType<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>::type createAccelerationStructureNV(
10098       const AccelerationStructureCreateInfoNV & createInfo,
10099       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10100       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10101 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10102     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10103     VULKAN_HPP_INLINE
10104       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::AccelerationStructureNV, Dispatch>>::type
10105       createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo,
10106                                            Optional<const AllocationCallbacks>       allocator
10107                                                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10108                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10109 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10110 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10111 
10112     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10113     void destroyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     accelerationStructure,
10114                                          const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10115                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10116       VULKAN_HPP_NOEXCEPT;
10117 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10118     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10119     void destroyAccelerationStructureNV(
10120       VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10121       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10122       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10123 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10124 
10125     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10126     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV     accelerationStructure,
10127                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10128                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10129 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10130     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10131     void destroy( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
10132                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10133                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10134 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10135 
10136     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10137     void getAccelerationStructureMemoryRequirementsNV(
10138       const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV * pInfo,
10139       VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR *                              pMemoryRequirements,
10140       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10141 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10142     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10143     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV(
10144       const AccelerationStructureMemoryRequirementsInfoNV & info,
10145       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10146     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10147     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV(
10148       const AccelerationStructureMemoryRequirementsInfoNV & info,
10149       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10150 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10151 
10152     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10153     VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV(
10154       uint32_t                                                            bindInfoCount,
10155       const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV * pBindInfos,
10156       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10157 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10158     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10159     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type bindAccelerationStructureMemoryNV(
10160       ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos,
10161       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10162 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10163 
10164     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10165     VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV(
10166       VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
10167       uint32_t                                                     createInfoCount,
10168       const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV * pCreateInfos,
10169       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *            pAllocator,
10170       VULKAN_HPP_NAMESPACE::Pipeline *                             pPipelines,
10171       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10172 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10173     template <typename PipelineAllocator = std::allocator<Pipeline>,
10174               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10175     VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createRayTracingPipelinesNV(
10176       VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
10177       ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
10178       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10179       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10180     template <typename PipelineAllocator = std::allocator<Pipeline>,
10181               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10182               typename B                 = PipelineAllocator,
10183               typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
10184     VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createRayTracingPipelinesNV(
10185       VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
10186       ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
10187       Optional<const AllocationCallbacks>                                            allocator,
10188       PipelineAllocator &                                                            pipelineAllocator,
10189       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10190     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10191     VULKAN_HPP_NODISCARD ResultValue<Pipeline> createRayTracingPipelineNV(
10192       VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
10193       const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
10194       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10195       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10196 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10197     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10198               typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
10199     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
10200                          createRayTracingPipelinesNVUnique(
10201                            VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
10202                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
10203                            Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10204                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10205     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10206               typename PipelineAllocator         = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
10207               typename B                         = PipelineAllocator,
10208               typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
10209                                       int>::type = 0>
10210     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
10211                          createRayTracingPipelinesNVUnique(
10212                            VULKAN_HPP_NAMESPACE::PipelineCache                                            pipelineCache,
10213                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
10214                            Optional<const AllocationCallbacks>                                            allocator,
10215                            PipelineAllocator &                                                            pipelineAllocator,
10216                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10217     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10218     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>> createRayTracingPipelineNVUnique(
10219       VULKAN_HPP_NAMESPACE::PipelineCache                          pipelineCache,
10220       const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV & createInfo,
10221       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10222       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10223 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10224 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10225 
10226     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10227     VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV(
10228       VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10229       uint32_t                       firstGroup,
10230       uint32_t                       groupCount,
10231       size_t                         dataSize,
10232       void *                         pData,
10233       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10234 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10235     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10236     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10237       getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10238                                          uint32_t                       firstGroup,
10239                                          uint32_t                       groupCount,
10240                                          ArrayProxy<T> const &          data,
10241                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10242     template <typename T,
10243               typename Allocator = std::allocator<T>,
10244               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10245     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
10246       getRayTracingShaderGroupHandlesNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10247                                          uint32_t                       firstGroup,
10248                                          uint32_t                       groupCount,
10249                                          size_t                         dataSize,
10250                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10251     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10252     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
10253       getRayTracingShaderGroupHandleNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10254                                         uint32_t                       firstGroup,
10255                                         uint32_t                       groupCount,
10256                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10257 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10258 
10259     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10260     VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV(
10261       VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
10262       size_t                                        dataSize,
10263       void *                                        pData,
10264       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10265 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10266     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10267     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10268       getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
10269                                         ArrayProxy<T> const &                         data,
10270                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10271     template <typename T,
10272               typename Allocator = std::allocator<T>,
10273               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10274     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
10275       getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
10276                                         size_t                                        dataSize,
10277                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10278     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10279     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
10280       getAccelerationStructureHandleNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure,
10281                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10282 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10283 
10284 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10285     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10286     VULKAN_HPP_NODISCARD Result
10287                          compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10288                                             uint32_t                       shader,
10289                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10290 #else
10291     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10292     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10293       compileDeferredNV( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10294                          uint32_t                       shader,
10295                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10296 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10297 
10298     //=== VK_KHR_maintenance3 ===
10299 
10300     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10301     void getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo * pCreateInfo,
10302                                            VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport *          pSupport,
10303                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10304       VULKAN_HPP_NOEXCEPT;
10305 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10306     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10307     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR(
10308       const DescriptorSetLayoutCreateInfo & createInfo,
10309       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10310     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10311     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getDescriptorSetLayoutSupportKHR(
10312       const DescriptorSetLayoutCreateInfo & createInfo,
10313       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10314 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10315 
10316     //=== VK_EXT_external_memory_host ===
10317 
10318     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10319     VULKAN_HPP_NODISCARD Result getMemoryHostPointerPropertiesEXT(
10320       VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
10321       const void *                                           pHostPointer,
10322       VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties,
10323       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10324 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10325     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10326     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
10327       typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>::type
10328       getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
10329                                          const void *                                           pHostPointer,
10330                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10331 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10332 
10333     //=== VK_EXT_calibrated_timestamps ===
10334 
10335     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10336     VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT(
10337       uint32_t                                                 timestampCount,
10338       const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT * pTimestampInfos,
10339       uint64_t *                                               pTimestamps,
10340       uint64_t *                                               pMaxDeviation,
10341       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10342 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10343     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10344     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type getCalibratedTimestampsEXT(
10345       ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
10346       ArrayProxy<uint64_t> const &                                               timestamps,
10347       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10348     template <typename Uint64_tAllocator = std::allocator<uint64_t>,
10349               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10350     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
10351       typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
10352       getCalibratedTimestampsEXT(
10353         ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
10354         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10355     template <typename Uint64_tAllocator = std::allocator<uint64_t>,
10356               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10357               typename B                 = Uint64_tAllocator,
10358               typename std::enable_if<std::is_same<typename B::value_type, uint64_t>::value, int>::type = 0>
10359     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
10360       typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
10361       getCalibratedTimestampsEXT(
10362         ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
10363         Uint64_tAllocator &                                                        uint64_tAllocator,
10364         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10365 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10366 
10367     //=== VK_KHR_timeline_semaphore ===
10368 
10369     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10370     VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR(
10371       VULKAN_HPP_NAMESPACE::Semaphore semaphore,
10372       uint64_t *                      pValue,
10373       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10374 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10375     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10376     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type
10377       getSemaphoreCounterValueKHR( VULKAN_HPP_NAMESPACE::Semaphore semaphore,
10378                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10379 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10380 
10381     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10382     VULKAN_HPP_NODISCARD Result
10383                          waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo * pWaitInfo,
10384                                             uint64_t                                        timeout,
10385                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10386 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10387     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10388     VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo,
10389                                                    uint64_t                  timeout,
10390                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10391 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10392 
10393     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10394     VULKAN_HPP_NODISCARD Result
10395                          signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo * pSignalInfo,
10396                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10397 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10398     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10399     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10400       signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo,
10401                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10402 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10403 
10404     //=== VK_INTEL_performance_query ===
10405 
10406     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10407     VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL(
10408       const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL * pInitializeInfo,
10409       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10410 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10411     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10412     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10413       initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo,
10414                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10415 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10416 
10417     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10418     void uninitializePerformanceApiINTEL( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10419       VULKAN_HPP_NOEXCEPT;
10420 
10421     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10422     VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL(
10423       const VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
10424       VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL *                  pConfiguration,
10425       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10426 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10427     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10428     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
10429       typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>::type
10430       acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
10431                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10432 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10433     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10434     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
10435       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL, Dispatch>>::type
10436       acquirePerformanceConfigurationINTELUnique( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo,
10437                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10438 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10439 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10440 
10441 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10442     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10443     VULKAN_HPP_NODISCARD Result releasePerformanceConfigurationINTEL(
10444       VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
10445       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10446 #else
10447     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10448     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type releasePerformanceConfigurationINTEL(
10449       VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10450       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10451 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10452 
10453 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10454     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10455     VULKAN_HPP_NODISCARD Result
10456                          release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
10457                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10458 #else
10459     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10460     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10461       release( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration,
10462                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10463 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10464 
10465     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10466     VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL(
10467       VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
10468       VULKAN_HPP_NAMESPACE::PerformanceValueINTEL *       pValue,
10469       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10470 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10471     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10472     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::PerformanceValueINTEL>::type
10473       getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter,
10474                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10475 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10476 
10477     //=== VK_AMD_display_native_hdr ===
10478 
10479     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10480     void setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::SwapchainKHR swapChain,
10481                              VULKAN_HPP_NAMESPACE::Bool32       localDimmingEnable,
10482                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10483 
10484     //=== VK_EXT_buffer_device_address ===
10485 
10486     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10487     DeviceAddress
10488       getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
10489                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10490 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10491     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10492     DeviceAddress
10493       getBufferAddressEXT( const BufferDeviceAddressInfo & info,
10494                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10495 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10496 
10497 #if defined( VK_USE_PLATFORM_WIN32_KHR )
10498     //=== VK_EXT_full_screen_exclusive ===
10499 
10500 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10501     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10502     VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT(
10503       VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
10504       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10505 #  else
10506     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10507     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10508       acquireFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
10509                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10510 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10511 
10512 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10513     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10514     VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT(
10515       VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
10516       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10517 #  else
10518     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10519     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10520       releaseFullScreenExclusiveModeEXT( VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain,
10521                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10522 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10523 
10524     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10525     VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModes2EXT(
10526       const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
10527       VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR *      pModes,
10528       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10529 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10530     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10531     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
10532       typename ResultValueType<VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR>::type
10533       getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
10534                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10535 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10536 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
10537 
10538     //=== VK_KHR_buffer_device_address ===
10539 
10540     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10541     DeviceAddress
10542       getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
10543                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10544 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10545     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10546     DeviceAddress
10547       getBufferAddressKHR( const BufferDeviceAddressInfo & info,
10548                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10549 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10550 
10551     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10552     uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo * pInfo,
10553                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10554       VULKAN_HPP_NOEXCEPT;
10555 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10556     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10557     uint64_t getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info,
10558                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10559       VULKAN_HPP_NOEXCEPT;
10560 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10561 
10562     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10563     uint64_t getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo * pInfo,
10564                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10565       VULKAN_HPP_NOEXCEPT;
10566 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10567     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10568     uint64_t getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo & info,
10569                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10570       VULKAN_HPP_NOEXCEPT;
10571 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10572 
10573     //=== VK_EXT_host_query_reset ===
10574 
10575     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10576     void resetQueryPoolEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
10577                             uint32_t                        firstQuery,
10578                             uint32_t                        queryCount,
10579                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10580 
10581     //=== VK_KHR_deferred_host_operations ===
10582 
10583     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10584     VULKAN_HPP_NODISCARD Result createDeferredOperationKHR(
10585       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10586       VULKAN_HPP_NAMESPACE::DeferredOperationKHR *      pDeferredOperation,
10587       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10588 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10589     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10590     typename ResultValueType<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>::type createDeferredOperationKHR(
10591       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10592       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10593 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10594     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10595     VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DeferredOperationKHR, Dispatch>>::type
10596       createDeferredOperationKHRUnique( Optional<const AllocationCallbacks> allocator
10597                                                                             VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10598                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10599 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10600 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10601 
10602     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10603     void destroyDeferredOperationKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
10604                                       const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10605                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10606       VULKAN_HPP_NOEXCEPT;
10607 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10608     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10609     void destroyDeferredOperationKHR(
10610       VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10611       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10612       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10613 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10614 
10615     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10616     void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR        operation,
10617                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10618                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10619 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10620     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10621     void destroy( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
10622                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10623                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10624 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10625 
10626     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10627     uint32_t getDeferredOperationMaxConcurrencyKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
10628                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10629       VULKAN_HPP_NOEXCEPT;
10630 
10631 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10632     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10633     VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR(
10634       VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
10635       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10636 #else
10637     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10638     VULKAN_HPP_NODISCARD Result
10639                          getDeferredOperationResultKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
10640                                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10641 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10642 
10643 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10644     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10645     VULKAN_HPP_NODISCARD Result
10646                          deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
10647                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10648 #else
10649     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10650     VULKAN_HPP_NODISCARD Result
10651                          deferredOperationJoinKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR operation,
10652                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10653 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10654 
10655     //=== VK_KHR_pipeline_executable_properties ===
10656 
10657     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10658     VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR(
10659       const VULKAN_HPP_NAMESPACE::PipelineInfoKHR *           pPipelineInfo,
10660       uint32_t *                                              pExecutableCount,
10661       VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR * pProperties,
10662       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10663 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10664     template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<PipelineExecutablePropertiesKHR>,
10665               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10666     VULKAN_HPP_NODISCARD typename ResultValueType<
10667       std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
10668       getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo,
10669                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10670     template <typename PipelineExecutablePropertiesKHRAllocator = std::allocator<PipelineExecutablePropertiesKHR>,
10671               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10672               typename B                                        = PipelineExecutablePropertiesKHRAllocator,
10673               typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutablePropertiesKHR>::value,
10674                                       int>::type                = 0>
10675     VULKAN_HPP_NODISCARD typename ResultValueType<
10676       std::vector<PipelineExecutablePropertiesKHR, PipelineExecutablePropertiesKHRAllocator>>::type
10677       getPipelineExecutablePropertiesKHR(
10678         const PipelineInfoKHR &                    pipelineInfo,
10679         PipelineExecutablePropertiesKHRAllocator & pipelineExecutablePropertiesKHRAllocator,
10680         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10681 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10682 
10683     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10684     VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR(
10685       const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR * pExecutableInfo,
10686       uint32_t *                                              pStatisticCount,
10687       VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR *  pStatistics,
10688       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10689 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10690     template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<PipelineExecutableStatisticKHR>,
10691               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10692     VULKAN_HPP_NODISCARD typename ResultValueType<
10693       std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
10694       getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo,
10695                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10696     template <typename PipelineExecutableStatisticKHRAllocator = std::allocator<PipelineExecutableStatisticKHR>,
10697               typename Dispatch                                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10698               typename B                                       = PipelineExecutableStatisticKHRAllocator,
10699               typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableStatisticKHR>::value,
10700                                       int>::type               = 0>
10701     VULKAN_HPP_NODISCARD typename ResultValueType<
10702       std::vector<PipelineExecutableStatisticKHR, PipelineExecutableStatisticKHRAllocator>>::type
10703       getPipelineExecutableStatisticsKHR(
10704         const PipelineExecutableInfoKHR &         executableInfo,
10705         PipelineExecutableStatisticKHRAllocator & pipelineExecutableStatisticKHRAllocator,
10706         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10707 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10708 
10709     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10710     VULKAN_HPP_NODISCARD Result getPipelineExecutableInternalRepresentationsKHR(
10711       const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR *             pExecutableInfo,
10712       uint32_t *                                                          pInternalRepresentationCount,
10713       VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR * pInternalRepresentations,
10714       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10715 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10716     template <typename PipelineExecutableInternalRepresentationKHRAllocator =
10717                 std::allocator<PipelineExecutableInternalRepresentationKHR>,
10718               typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10719     VULKAN_HPP_NODISCARD
10720       typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,
10721                                            PipelineExecutableInternalRepresentationKHRAllocator>>::type
10722       getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo,
10723                                                        Dispatch const &                  d
10724                                                                                          VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10725     template <
10726       typename PipelineExecutableInternalRepresentationKHRAllocator =
10727         std::allocator<PipelineExecutableInternalRepresentationKHR>,
10728       typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10729       typename B                         = PipelineExecutableInternalRepresentationKHRAllocator,
10730       typename std::enable_if<std::is_same<typename B::value_type, PipelineExecutableInternalRepresentationKHR>::value,
10731                               int>::type = 0>
10732     VULKAN_HPP_NODISCARD
10733       typename ResultValueType<std::vector<PipelineExecutableInternalRepresentationKHR,
10734                                            PipelineExecutableInternalRepresentationKHRAllocator>>::type
10735       getPipelineExecutableInternalRepresentationsKHR(
10736         const PipelineExecutableInfoKHR &                      executableInfo,
10737         PipelineExecutableInternalRepresentationKHRAllocator & pipelineExecutableInternalRepresentationKHRAllocator,
10738         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10739 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10740 
10741     //=== VK_NV_device_generated_commands ===
10742 
10743     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10744     void getGeneratedCommandsMemoryRequirementsNV(
10745       const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV * pInfo,
10746       VULKAN_HPP_NAMESPACE::MemoryRequirements2 *                             pMemoryRequirements,
10747       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10748 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10749     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10750     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2 getGeneratedCommandsMemoryRequirementsNV(
10751       const GeneratedCommandsMemoryRequirementsInfoNV & info,
10752       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10753     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10754     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...> getGeneratedCommandsMemoryRequirementsNV(
10755       const GeneratedCommandsMemoryRequirementsInfoNV & info,
10756       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10757 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10758 
10759     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10760     VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV(
10761       const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV * pCreateInfo,
10762       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                pAllocator,
10763       VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV *                 pIndirectCommandsLayout,
10764       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10765 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10766     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10767     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
10768       typename ResultValueType<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>::type
10769       createIndirectCommandsLayoutNV( const IndirectCommandsLayoutCreateInfoNV & createInfo,
10770                                       Optional<const AllocationCallbacks>        allocator
10771                                                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10772                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10773 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10774     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10775     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
10776       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV, Dispatch>>::type
10777       createIndirectCommandsLayoutNVUnique( const IndirectCommandsLayoutCreateInfoNV & createInfo,
10778                                             Optional<const AllocationCallbacks>        allocator
10779                                                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10780                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10781 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10782 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10783 
10784     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10785     void destroyIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,
10786                                           const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10787                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10788       VULKAN_HPP_NOEXCEPT;
10789 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10790     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10791     void destroyIndirectCommandsLayoutNV(
10792       VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10793       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10794       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10795 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10796 
10797     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10798     void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV    indirectCommandsLayout,
10799                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10800                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10801 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10802     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10803     void destroy( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout,
10804                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10805                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10806 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10807 
10808     //=== VK_EXT_private_data ===
10809 
10810     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10811     VULKAN_HPP_NODISCARD Result
10812                          createPrivateDataSlotEXT( const VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfoEXT * pCreateInfo,
10813                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
10814                                                    VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT *                 pPrivateDataSlot,
10815                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10816 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10817     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10818     typename ResultValueType<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT>::type createPrivateDataSlotEXT(
10819       const PrivateDataSlotCreateInfoEXT & createInfo,
10820       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10821       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10822 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10823     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10824     VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT, Dispatch>>::type
10825       createPrivateDataSlotEXTUnique( const PrivateDataSlotCreateInfoEXT & createInfo,
10826                                       Optional<const AllocationCallbacks>  allocator
10827                                                                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10828                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10829 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10830 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10831 
10832     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10833     void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT          privateDataSlot,
10834                                     const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10835                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
10836       VULKAN_HPP_NOEXCEPT;
10837 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10838     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10839     void destroyPrivateDataSlotEXT(
10840       VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
10841       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10842       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10843 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10844 
10845     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10846     void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT          privateDataSlot,
10847                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
10848                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10849 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10850     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10851     void destroy( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
10852                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10853                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10854 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10855 
10856 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
10857     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10858     VULKAN_HPP_NODISCARD Result
10859                          setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
10860                                             uint64_t                                 objectHandle,
10861                                             VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
10862                                             uint64_t                                 data,
10863                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10864 #else
10865     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10866     typename ResultValueType<void>::type
10867          setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
10868                             uint64_t                                 objectHandle,
10869                             VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
10870                             uint64_t                                 data,
10871                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10872 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10873 
10874     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10875     void getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
10876                             uint64_t                                 objectHandle,
10877                             VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
10878                             uint64_t *                               pData,
10879                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10880 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10881     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10882     VULKAN_HPP_NODISCARD uint64_t
10883                          getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType         objectType,
10884                                             uint64_t                                 objectHandle,
10885                                             VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT privateDataSlot,
10886                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10887 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10888 
10889     //=== VK_KHR_ray_tracing_pipeline ===
10890 
10891     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10892     VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR(
10893       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                    deferredOperation,
10894       VULKAN_HPP_NAMESPACE::PipelineCache                           pipelineCache,
10895       uint32_t                                                      createInfoCount,
10896       const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR * pCreateInfos,
10897       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *             pAllocator,
10898       VULKAN_HPP_NAMESPACE::Pipeline *                              pPipelines,
10899       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10900 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10901     template <typename PipelineAllocator = std::allocator<Pipeline>,
10902               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10903     VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createRayTracingPipelinesKHR(
10904       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                      deferredOperation,
10905       VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
10906       ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
10907       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10908       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10909     template <typename PipelineAllocator = std::allocator<Pipeline>,
10910               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10911               typename B                 = PipelineAllocator,
10912               typename std::enable_if<std::is_same<typename B::value_type, Pipeline>::value, int>::type = 0>
10913     VULKAN_HPP_NODISCARD ResultValue<std::vector<Pipeline, PipelineAllocator>> createRayTracingPipelinesKHR(
10914       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                      deferredOperation,
10915       VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
10916       ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
10917       Optional<const AllocationCallbacks>                                             allocator,
10918       PipelineAllocator &                                                             pipelineAllocator,
10919       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10920     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10921     VULKAN_HPP_NODISCARD ResultValue<Pipeline> createRayTracingPipelineKHR(
10922       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                    deferredOperation,
10923       VULKAN_HPP_NAMESPACE::PipelineCache                           pipelineCache,
10924       const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo,
10925       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10926       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10927 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
10928     template <typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10929               typename PipelineAllocator = std::allocator<UniqueHandle<Pipeline, Dispatch>>>
10930     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
10931                          createRayTracingPipelinesKHRUnique(
10932                            VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                      deferredOperation,
10933                            VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
10934                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
10935                            Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10936                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10937     template <typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
10938               typename PipelineAllocator         = std::allocator<UniqueHandle<Pipeline, Dispatch>>,
10939               typename B                         = PipelineAllocator,
10940               typename std::enable_if<std::is_same<typename B::value_type, UniqueHandle<Pipeline, Dispatch>>::value,
10941                                       int>::type = 0>
10942     VULKAN_HPP_NODISCARD ResultValue<std::vector<UniqueHandle<Pipeline, Dispatch>, PipelineAllocator>>
10943                          createRayTracingPipelinesKHRUnique(
10944                            VULKAN_HPP_NAMESPACE::DeferredOperationKHR                                      deferredOperation,
10945                            VULKAN_HPP_NAMESPACE::PipelineCache                                             pipelineCache,
10946                            ArrayProxy<const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
10947                            Optional<const AllocationCallbacks>                                             allocator,
10948                            PipelineAllocator &                                                             pipelineAllocator,
10949                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10950     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10951     VULKAN_HPP_NODISCARD ResultValue<UniqueHandle<Pipeline, Dispatch>> createRayTracingPipelineKHRUnique(
10952       VULKAN_HPP_NAMESPACE::DeferredOperationKHR                    deferredOperation,
10953       VULKAN_HPP_NAMESPACE::PipelineCache                           pipelineCache,
10954       const VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR & createInfo,
10955       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
10956       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10957 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
10958 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10959 
10960     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10961     VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR(
10962       VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10963       uint32_t                       firstGroup,
10964       uint32_t                       groupCount,
10965       size_t                         dataSize,
10966       void *                         pData,
10967       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
10968 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
10969     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10970     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
10971       getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10972                                           uint32_t                       firstGroup,
10973                                           uint32_t                       groupCount,
10974                                           ArrayProxy<T> const &          data,
10975                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10976     template <typename T,
10977               typename Allocator = std::allocator<T>,
10978               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10979     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
10980       getRayTracingShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10981                                           uint32_t                       firstGroup,
10982                                           uint32_t                       groupCount,
10983                                           size_t                         dataSize,
10984                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10985     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10986     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
10987       getRayTracingShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10988                                          uint32_t                       firstGroup,
10989                                          uint32_t                       groupCount,
10990                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
10991 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
10992 
10993     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
10994     VULKAN_HPP_NODISCARD Result getRayTracingCaptureReplayShaderGroupHandlesKHR(
10995       VULKAN_HPP_NAMESPACE::Pipeline pipeline,
10996       uint32_t                       firstGroup,
10997       uint32_t                       groupCount,
10998       size_t                         dataSize,
10999       void *                         pData,
11000       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11001 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11002     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11003     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
11004       getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11005                                                        uint32_t                       firstGroup,
11006                                                        uint32_t                       groupCount,
11007                                                        ArrayProxy<T> const &          data,
11008                                                        Dispatch const &               d
11009                                                                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11010     template <typename T,
11011               typename Allocator = std::allocator<T>,
11012               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11013     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::vector<T, Allocator>>::type
11014       getRayTracingCaptureReplayShaderGroupHandlesKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11015                                                        uint32_t                       firstGroup,
11016                                                        uint32_t                       groupCount,
11017                                                        size_t                         dataSize,
11018                                                        Dispatch const &               d
11019                                                                                       VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11020     template <typename T, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11021     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<T>::type
11022       getRayTracingCaptureReplayShaderGroupHandleKHR( VULKAN_HPP_NAMESPACE::Pipeline pipeline,
11023                                                       uint32_t                       firstGroup,
11024                                                       uint32_t                       groupCount,
11025                                                       Dispatch const &               d
11026                                                                                      VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11027 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11028 
11029     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11030     DeviceSize getRayTracingShaderGroupStackSizeKHR( VULKAN_HPP_NAMESPACE::Pipeline             pipeline,
11031                                                      uint32_t                                   group,
11032                                                      VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader,
11033                                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11034       VULKAN_HPP_NOEXCEPT;
11035 
11036 #if defined( VK_USE_PLATFORM_FUCHSIA )
11037     //=== VK_FUCHSIA_external_memory ===
11038 
11039     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11040     VULKAN_HPP_NODISCARD Result getMemoryZirconHandleFUCHSIA(
11041       const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
11042       zx_handle_t *                                                  pZirconHandle,
11043       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11044 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11045     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11046     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<zx_handle_t>::type
11047       getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
11048                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11049 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11050 
11051     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11052     VULKAN_HPP_NODISCARD Result getMemoryZirconHandlePropertiesFUCHSIA(
11053       VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits      handleType,
11054       zx_handle_t                                                 zirconHandle,
11055       VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties,
11056       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11057 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11058     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11059     typename ResultValueType<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>::type
11060       getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType,
11061                                               zx_handle_t                                            zirconHandle,
11062                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11063 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11064 #endif   /*VK_USE_PLATFORM_FUCHSIA*/
11065 
11066 #if defined( VK_USE_PLATFORM_FUCHSIA )
11067     //=== VK_FUCHSIA_external_semaphore ===
11068 
11069     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11070     VULKAN_HPP_NODISCARD Result importSemaphoreZirconHandleFUCHSIA(
11071       const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo,
11072       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11073 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11074     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11075     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type importSemaphoreZirconHandleFUCHSIA(
11076       const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo,
11077       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11078 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11079 
11080     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11081     VULKAN_HPP_NODISCARD Result getSemaphoreZirconHandleFUCHSIA(
11082       const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
11083       zx_handle_t *                                                     pZirconHandle,
11084       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11085 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11086     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11087     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<zx_handle_t>::type
11088       getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo,
11089                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11090 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11091 #endif   /*VK_USE_PLATFORM_FUCHSIA*/
11092 
11093     //=== VK_HUAWEI_subpass_shading ===
11094 
11095     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11096     VULKAN_HPP_NODISCARD Result getSubpassShadingMaxWorkgroupSizeHUAWEI(
11097       VULKAN_HPP_NAMESPACE::RenderPass renderpass,
11098       VULKAN_HPP_NAMESPACE::Extent2D * pMaxWorkgroupSize,
11099       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11100 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11101     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11102     VULKAN_HPP_NODISCARD ResultValue<VULKAN_HPP_NAMESPACE::Extent2D>
11103                          getSubpassShadingMaxWorkgroupSizeHUAWEI( VULKAN_HPP_NAMESPACE::RenderPass renderpass,
11104                                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11105 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11106 
11107     //=== VK_NV_external_memory_rdma ===
11108 
11109     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11110     VULKAN_HPP_NODISCARD Result
11111                          getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV * getMemoryRemoteAddressInfo,
11112                                                    VULKAN_HPP_NAMESPACE::RemoteAddressNV *                    pAddress,
11113                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11114 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11115     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11116     typename ResultValueType<VULKAN_HPP_NAMESPACE::RemoteAddressNV>::type
11117       getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV & getMemoryRemoteAddressInfo,
11118                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11119 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11120 
operator VkDevice() const11121     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const VULKAN_HPP_NOEXCEPT
11122     {
11123       return m_device;
11124     }
11125 
operator bool() const11126     explicit operator bool() const VULKAN_HPP_NOEXCEPT
11127     {
11128       return m_device != VK_NULL_HANDLE;
11129     }
11130 
operator !() const11131     bool operator!() const VULKAN_HPP_NOEXCEPT
11132     {
11133       return m_device == VK_NULL_HANDLE;
11134     }
11135 
11136   private:
11137     VkDevice m_device = {};
11138   };
11139   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Device ) == sizeof( VkDevice ),
11140                  "handle and wrapper have different size!" );
11141 
11142   template <>
11143   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDevice>
11144   {
11145     using type = VULKAN_HPP_NAMESPACE::Device;
11146   };
11147 
11148   template <>
11149   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDevice>
11150   {
11151     using Type = VULKAN_HPP_NAMESPACE::Device;
11152   };
11153 
11154   template <>
11155   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
11156                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice>
11157   {
11158     using Type = VULKAN_HPP_NAMESPACE::Device;
11159   };
11160 
11161   template <>
11162   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Device>
11163   {
11164     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
11165   };
11166 
11167   class DisplayModeKHR
11168   {
11169   public:
11170     using CType = VkDisplayModeKHR;
11171 
11172     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
11173       VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR;
11174     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
11175       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR;
11176 
11177   public:
11178     VULKAN_HPP_CONSTEXPR         DisplayModeKHR() = default;
DisplayModeKHR(std::nullptr_t)11179     VULKAN_HPP_CONSTEXPR         DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
DisplayModeKHR(VkDisplayModeKHR displayModeKHR)11180     VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT
11181       : m_displayModeKHR( displayModeKHR )
11182     {}
11183 
11184 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkDisplayModeKHR displayModeKHR)11185     DisplayModeKHR & operator=( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT
11186     {
11187       m_displayModeKHR = displayModeKHR;
11188       return *this;
11189     }
11190 #endif
11191 
operator =(std::nullptr_t)11192     DisplayModeKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
11193     {
11194       m_displayModeKHR = {};
11195       return *this;
11196     }
11197 
11198 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
11199     auto operator<=>( DisplayModeKHR const & ) const = default;
11200 #else
operator ==(DisplayModeKHR const & rhs) const11201     bool operator==( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
11202     {
11203       return m_displayModeKHR == rhs.m_displayModeKHR;
11204     }
11205 
operator !=(DisplayModeKHR const & rhs) const11206     bool operator!=( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
11207     {
11208       return m_displayModeKHR != rhs.m_displayModeKHR;
11209     }
11210 
operator <(DisplayModeKHR const & rhs) const11211     bool operator<( DisplayModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
11212     {
11213       return m_displayModeKHR < rhs.m_displayModeKHR;
11214     }
11215 #endif
11216 
operator VkDisplayModeKHR() const11217     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const VULKAN_HPP_NOEXCEPT
11218     {
11219       return m_displayModeKHR;
11220     }
11221 
operator bool() const11222     explicit operator bool() const VULKAN_HPP_NOEXCEPT
11223     {
11224       return m_displayModeKHR != VK_NULL_HANDLE;
11225     }
11226 
operator !() const11227     bool operator!() const VULKAN_HPP_NOEXCEPT
11228     {
11229       return m_displayModeKHR == VK_NULL_HANDLE;
11230     }
11231 
11232   private:
11233     VkDisplayModeKHR m_displayModeKHR = {};
11234   };
11235   static_assert( sizeof( VULKAN_HPP_NAMESPACE::DisplayModeKHR ) == sizeof( VkDisplayModeKHR ),
11236                  "handle and wrapper have different size!" );
11237 
11238   template <>
11239   struct VULKAN_HPP_DEPRECATED(
11240     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eDisplayModeKHR>
11241   {
11242     using type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
11243   };
11244 
11245   template <>
11246   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR>
11247   {
11248     using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
11249   };
11250 
11251   template <>
11252   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
11253                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR>
11254   {
11255     using Type = VULKAN_HPP_NAMESPACE::DisplayModeKHR;
11256   };
11257 
11258   template <>
11259   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>
11260   {
11261     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
11262   };
11263 
11264 #ifndef VULKAN_HPP_NO_SMART_HANDLE
11265   template <typename Dispatch>
11266   class UniqueHandleTraits<Device, Dispatch>
11267   {
11268   public:
11269     using deleter = ObjectDestroy<NoParent, Dispatch>;
11270   };
11271   using UniqueDevice = UniqueHandle<Device, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
11272 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
11273 
11274   class PhysicalDevice
11275   {
11276   public:
11277     using CType = VkPhysicalDevice;
11278 
11279     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
11280       VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice;
11281     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
11282       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice;
11283 
11284   public:
11285     VULKAN_HPP_CONSTEXPR         PhysicalDevice() = default;
PhysicalDevice(std::nullptr_t)11286     VULKAN_HPP_CONSTEXPR         PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
PhysicalDevice(VkPhysicalDevice physicalDevice)11287     VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT
11288       : m_physicalDevice( physicalDevice )
11289     {}
11290 
11291 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkPhysicalDevice physicalDevice)11292     PhysicalDevice & operator=( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT
11293     {
11294       m_physicalDevice = physicalDevice;
11295       return *this;
11296     }
11297 #endif
11298 
operator =(std::nullptr_t)11299     PhysicalDevice & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
11300     {
11301       m_physicalDevice = {};
11302       return *this;
11303     }
11304 
11305 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
11306     auto operator<=>( PhysicalDevice const & ) const = default;
11307 #else
operator ==(PhysicalDevice const & rhs) const11308     bool operator==( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
11309     {
11310       return m_physicalDevice == rhs.m_physicalDevice;
11311     }
11312 
operator !=(PhysicalDevice const & rhs) const11313     bool operator!=( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
11314     {
11315       return m_physicalDevice != rhs.m_physicalDevice;
11316     }
11317 
operator <(PhysicalDevice const & rhs) const11318     bool operator<( PhysicalDevice const & rhs ) const VULKAN_HPP_NOEXCEPT
11319     {
11320       return m_physicalDevice < rhs.m_physicalDevice;
11321     }
11322 #endif
11323 
11324     //=== VK_VERSION_1_0 ===
11325 
11326     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11327     void getFeatures( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * pFeatures,
11328                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11329 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11330     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11331     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures
11332                          getFeatures( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11333 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11334 
11335     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11336     void getFormatProperties( VULKAN_HPP_NAMESPACE::Format             format,
11337                               VULKAN_HPP_NAMESPACE::FormatProperties * pFormatProperties,
11338                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11339 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11340     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11341     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties
11342                          getFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
11343                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11344 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11345 
11346     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11347     VULKAN_HPP_NODISCARD Result
11348                          getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                  format,
11349                                                    VULKAN_HPP_NAMESPACE::ImageType               type,
11350                                                    VULKAN_HPP_NAMESPACE::ImageTiling             tiling,
11351                                                    VULKAN_HPP_NAMESPACE::ImageUsageFlags         usage,
11352                                                    VULKAN_HPP_NAMESPACE::ImageCreateFlags        flags,
11353                                                    VULKAN_HPP_NAMESPACE::ImageFormatProperties * pImageFormatProperties,
11354                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11355 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11356     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11357     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties>::type
11358       getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format           format,
11359                                 VULKAN_HPP_NAMESPACE::ImageType        type,
11360                                 VULKAN_HPP_NAMESPACE::ImageTiling      tiling,
11361                                 VULKAN_HPP_NAMESPACE::ImageUsageFlags  usage,
11362                                 VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11363                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11364 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11365 
11366     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11367     void getProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties * pProperties,
11368                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11369 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11370     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11371     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties
11372                          getProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11373 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11374 
11375     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11376     void
11377       getQueueFamilyProperties( uint32_t *                                    pQueueFamilyPropertyCount,
11378                                 VULKAN_HPP_NAMESPACE::QueueFamilyProperties * pQueueFamilyProperties,
11379                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11380 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11381     template <typename QueueFamilyPropertiesAllocator = std::allocator<QueueFamilyProperties>,
11382               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11383     VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
11384                          getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11385     template <
11386       typename QueueFamilyPropertiesAllocator = std::allocator<QueueFamilyProperties>,
11387       typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11388       typename B                              = QueueFamilyPropertiesAllocator,
11389       typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties>::value, int>::type = 0>
11390     VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties, QueueFamilyPropertiesAllocator>
11391                          getQueueFamilyProperties( QueueFamilyPropertiesAllocator & queueFamilyPropertiesAllocator,
11392                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11393 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11394 
11395     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11396     void getMemoryProperties( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties * pMemoryProperties,
11397                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11398 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11399     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11400     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties
11401                          getMemoryProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11402 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11403 
11404     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11405     VULKAN_HPP_NODISCARD Result
11406                          createDevice( const VULKAN_HPP_NAMESPACE::DeviceCreateInfo *    pCreateInfo,
11407                                        const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
11408                                        VULKAN_HPP_NAMESPACE::Device *                    pDevice,
11409                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11410 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11411     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11412     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Device>::type
11413       createDevice( const DeviceCreateInfo &            createInfo,
11414                     Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11415                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11416 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11417     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11418     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
11419       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Device, Dispatch>>::type
11420       createDeviceUnique( const DeviceCreateInfo &            createInfo,
11421                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11422                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11423 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
11424 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11425 
11426     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11427     VULKAN_HPP_NODISCARD Result enumerateDeviceExtensionProperties(
11428       const char *                                pLayerName,
11429       uint32_t *                                  pPropertyCount,
11430       VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties,
11431       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11432 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11433     template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
11434               typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11435     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
11436       enumerateDeviceExtensionProperties( Optional<const std::string> layerName
11437                                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11438                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11439     template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
11440               typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11441               typename B                            = ExtensionPropertiesAllocator,
11442               typename std::enable_if<std::is_same<typename B::value_type, ExtensionProperties>::value, int>::type = 0>
11443     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
11444       enumerateDeviceExtensionProperties( Optional<const std::string>    layerName,
11445                                           ExtensionPropertiesAllocator & extensionPropertiesAllocator,
11446                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11447 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11448 
11449     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11450     VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties(
11451       uint32_t *                              pPropertyCount,
11452       VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,
11453       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11454 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11455     template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
11456               typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11457     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
11458       enumerateDeviceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11459     template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
11460               typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11461               typename B                        = LayerPropertiesAllocator,
11462               typename std::enable_if<std::is_same<typename B::value_type, LayerProperties>::value, int>::type = 0>
11463     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
11464       enumerateDeviceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator,
11465                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11466 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11467 
11468     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11469     void getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format                        format,
11470                                          VULKAN_HPP_NAMESPACE::ImageType                     type,
11471                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits           samples,
11472                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags               usage,
11473                                          VULKAN_HPP_NAMESPACE::ImageTiling                   tiling,
11474                                          uint32_t *                                          pPropertyCount,
11475                                          VULKAN_HPP_NAMESPACE::SparseImageFormatProperties * pProperties,
11476                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11477       VULKAN_HPP_NOEXCEPT;
11478 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11479     template <typename SparseImageFormatPropertiesAllocator = std::allocator<SparseImageFormatProperties>,
11480               typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11481     VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
11482                          getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
11483                                                          VULKAN_HPP_NAMESPACE::ImageType           type,
11484                                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
11485                                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
11486                                                          VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
11487                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11488     template <
11489       typename SparseImageFormatPropertiesAllocator = std::allocator<SparseImageFormatProperties>,
11490       typename Dispatch                             = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11491       typename B                                    = SparseImageFormatPropertiesAllocator,
11492       typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties>::value, int>::type = 0>
11493     VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties, SparseImageFormatPropertiesAllocator>
11494                          getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format              format,
11495                                                          VULKAN_HPP_NAMESPACE::ImageType           type,
11496                                                          VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
11497                                                          VULKAN_HPP_NAMESPACE::ImageUsageFlags     usage,
11498                                                          VULKAN_HPP_NAMESPACE::ImageTiling         tiling,
11499                                                          SparseImageFormatPropertiesAllocator &    sparseImageFormatPropertiesAllocator,
11500                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11501 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11502 
11503     //=== VK_VERSION_1_1 ===
11504 
11505     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11506     void getFeatures2( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
11507                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11508 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11509     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11510     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
11511                          getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11512     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11513     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
11514                          getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11515 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11516 
11517     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11518     void getProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
11519                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11520 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11521     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11522     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
11523                          getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11524     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11525     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
11526                          getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11527 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11528 
11529     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11530     void getFormatProperties2( VULKAN_HPP_NAMESPACE::Format              format,
11531                                VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
11532                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11533 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11534     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11535     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
11536                          getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format,
11537                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11538     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11539     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
11540                          getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format,
11541                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11542 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11543 
11544     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11545     VULKAN_HPP_NODISCARD Result getImageFormatProperties2(
11546       const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
11547       VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,
11548       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11549 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11550     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11551     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
11552       getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
11553                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11554     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11555     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
11556       getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
11557                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11558 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11559 
11560     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11561     void getQueueFamilyProperties2( uint32_t *                                     pQueueFamilyPropertyCount,
11562                                     VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
11563                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11564       VULKAN_HPP_NOEXCEPT;
11565 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11566     template <typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
11567               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11568     VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
11569                          getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11570     template <
11571       typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
11572       typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11573       typename B                               = QueueFamilyProperties2Allocator,
11574       typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type = 0>
11575     VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
11576                          getQueueFamilyProperties2( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
11577                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11578     template <typename StructureChain,
11579               typename StructureChainAllocator = std::allocator<StructureChain>,
11580               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11581     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
11582                          getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11583     template <typename StructureChain,
11584               typename StructureChainAllocator = std::allocator<StructureChain>,
11585               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11586               typename B                       = StructureChainAllocator,
11587               typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type = 0>
11588     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
11589                          getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator,
11590                                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11591 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11592 
11593     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11594     void getMemoryProperties2( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
11595                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11596 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11597     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11598     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
11599                          getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11600     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11601     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
11602                          getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11603 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11604 
11605     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11606     void getSparseImageFormatProperties2(
11607       const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
11608       uint32_t *                                                         pPropertyCount,
11609       VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,
11610       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11611 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11612     template <typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
11613               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11614     VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
11615                          getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
11616                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11617     template <
11618       typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
11619       typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11620       typename B                                     = SparseImageFormatProperties2Allocator,
11621       typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type = 0>
11622     VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
11623                          getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
11624                                                           SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
11625                                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11626 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11627 
11628     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11629     void getExternalBufferProperties(
11630       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
11631       VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,
11632       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11633 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11634     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11635     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferProperties(
11636       const PhysicalDeviceExternalBufferInfo & externalBufferInfo,
11637       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11638 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11639 
11640     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11641     void getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
11642                                      VULKAN_HPP_NAMESPACE::ExternalFenceProperties * pExternalFenceProperties,
11643                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11644       VULKAN_HPP_NOEXCEPT;
11645 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11646     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11647     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFenceProperties(
11648       const PhysicalDeviceExternalFenceInfo & externalFenceInfo,
11649       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11650 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11651 
11652     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11653     void getExternalSemaphoreProperties(
11654       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
11655       VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,
11656       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11657 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11658     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11659     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphoreProperties(
11660       const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
11661       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11662 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11663 
11664     //=== VK_KHR_surface ===
11665 
11666     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11667     VULKAN_HPP_NODISCARD Result
11668                          getSurfaceSupportKHR( uint32_t                         queueFamilyIndex,
11669                                                VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
11670                                                VULKAN_HPP_NAMESPACE::Bool32 *   pSupported,
11671                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11672 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11673     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11674     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Bool32>::type
11675       getSurfaceSupportKHR( uint32_t                         queueFamilyIndex,
11676                             VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
11677                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11678 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11679 
11680     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11681     VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR(
11682       VULKAN_HPP_NAMESPACE::SurfaceKHR               surface,
11683       VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR * pSurfaceCapabilities,
11684       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11685 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11686     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11687     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>::type
11688       getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
11689                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11690 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11691 
11692     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11693     VULKAN_HPP_NODISCARD Result
11694                          getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR         surface,
11695                                                uint32_t *                               pSurfaceFormatCount,
11696                                                VULKAN_HPP_NAMESPACE::SurfaceFormatKHR * pSurfaceFormats,
11697                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11698 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11699     template <typename SurfaceFormatKHRAllocator = std::allocator<SurfaceFormatKHR>,
11700               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11701     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
11702       getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
11703                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11704     template <typename SurfaceFormatKHRAllocator = std::allocator<SurfaceFormatKHR>,
11705               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11706               typename B                         = SurfaceFormatKHRAllocator,
11707               typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormatKHR>::value, int>::type = 0>
11708     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormatKHR, SurfaceFormatKHRAllocator>>::type
11709       getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
11710                             SurfaceFormatKHRAllocator &      surfaceFormatKHRAllocator,
11711                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11712 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11713 
11714     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11715     VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR(
11716       VULKAN_HPP_NAMESPACE::SurfaceKHR       surface,
11717       uint32_t *                             pPresentModeCount,
11718       VULKAN_HPP_NAMESPACE::PresentModeKHR * pPresentModes,
11719       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11720 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11721     template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
11722               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11723     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
11724       getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
11725                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11726     template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
11727               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11728               typename B                       = PresentModeKHRAllocator,
11729               typename std::enable_if<std::is_same<typename B::value_type, PresentModeKHR>::value, int>::type = 0>
11730     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
11731       getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
11732                                  PresentModeKHRAllocator &        presentModeKHRAllocator,
11733                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11734 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11735 
11736     //=== VK_KHR_swapchain ===
11737 
11738     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11739     VULKAN_HPP_NODISCARD Result
11740                          getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
11741                                                   uint32_t *                       pRectCount,
11742                                                   VULKAN_HPP_NAMESPACE::Rect2D *   pRects,
11743                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11744 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11745     template <typename Rect2DAllocator = std::allocator<Rect2D>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11746     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
11747       getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
11748                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11749     template <typename Rect2DAllocator = std::allocator<Rect2D>,
11750               typename Dispatch        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11751               typename B               = Rect2DAllocator,
11752               typename std::enable_if<std::is_same<typename B::value_type, Rect2D>::value, int>::type = 0>
11753     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<Rect2D, Rect2DAllocator>>::type
11754       getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
11755                                Rect2DAllocator &                rect2DAllocator,
11756                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11757 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11758 
11759     //=== VK_KHR_display ===
11760 
11761     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11762     VULKAN_HPP_NODISCARD Result
11763                          getDisplayPropertiesKHR( uint32_t *                                   pPropertyCount,
11764                                                   VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR * pProperties,
11765                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11766 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11767     template <typename DisplayPropertiesKHRAllocator = std::allocator<DisplayPropertiesKHR>,
11768               typename Dispatch                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11769     VULKAN_HPP_NODISCARD
11770       typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
11771       getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11772     template <typename DisplayPropertiesKHRAllocator = std::allocator<DisplayPropertiesKHR>,
11773               typename Dispatch                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11774               typename B                             = DisplayPropertiesKHRAllocator,
11775               typename std::enable_if<std::is_same<typename B::value_type, DisplayPropertiesKHR>::value, int>::type = 0>
11776     VULKAN_HPP_NODISCARD
11777       typename ResultValueType<std::vector<DisplayPropertiesKHR, DisplayPropertiesKHRAllocator>>::type
11778       getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator & displayPropertiesKHRAllocator,
11779                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11780 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11781 
11782     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11783     VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR(
11784       uint32_t *                                        pPropertyCount,
11785       VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR * pProperties,
11786       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11787 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11788     template <typename DisplayPlanePropertiesKHRAllocator = std::allocator<DisplayPlanePropertiesKHR>,
11789               typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11790     VULKAN_HPP_NODISCARD
11791       typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
11792       getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11793     template <
11794       typename DisplayPlanePropertiesKHRAllocator = std::allocator<DisplayPlanePropertiesKHR>,
11795       typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11796       typename B                                  = DisplayPlanePropertiesKHRAllocator,
11797       typename std::enable_if<std::is_same<typename B::value_type, DisplayPlanePropertiesKHR>::value, int>::type = 0>
11798     VULKAN_HPP_NODISCARD
11799       typename ResultValueType<std::vector<DisplayPlanePropertiesKHR, DisplayPlanePropertiesKHRAllocator>>::type
11800       getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator & displayPlanePropertiesKHRAllocator,
11801                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11802 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11803 
11804     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11805     VULKAN_HPP_NODISCARD Result getDisplayPlaneSupportedDisplaysKHR(
11806       uint32_t                           planeIndex,
11807       uint32_t *                         pDisplayCount,
11808       VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplays,
11809       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11810 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11811     template <typename DisplayKHRAllocator = std::allocator<DisplayKHR>,
11812               typename Dispatch            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11813     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type
11814       getDisplayPlaneSupportedDisplaysKHR( uint32_t         planeIndex,
11815                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11816     template <typename DisplayKHRAllocator = std::allocator<DisplayKHR>,
11817               typename Dispatch            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11818               typename B                   = DisplayKHRAllocator,
11819               typename std::enable_if<std::is_same<typename B::value_type, DisplayKHR>::value, int>::type = 0>
11820     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<DisplayKHR, DisplayKHRAllocator>>::type
11821       getDisplayPlaneSupportedDisplaysKHR( uint32_t              planeIndex,
11822                                            DisplayKHRAllocator & displayKHRAllocator,
11823                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11824 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11825 
11826     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11827     VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR(
11828       VULKAN_HPP_NAMESPACE::DisplayKHR                 display,
11829       uint32_t *                                       pPropertyCount,
11830       VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR * pProperties,
11831       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11832 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11833     template <typename DisplayModePropertiesKHRAllocator = std::allocator<DisplayModePropertiesKHR>,
11834               typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11835     VULKAN_HPP_NODISCARD
11836       typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
11837       getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
11838                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11839     template <
11840       typename DisplayModePropertiesKHRAllocator = std::allocator<DisplayModePropertiesKHR>,
11841       typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11842       typename B                                 = DisplayModePropertiesKHRAllocator,
11843       typename std::enable_if<std::is_same<typename B::value_type, DisplayModePropertiesKHR>::value, int>::type = 0>
11844     VULKAN_HPP_NODISCARD
11845       typename ResultValueType<std::vector<DisplayModePropertiesKHR, DisplayModePropertiesKHRAllocator>>::type
11846       getDisplayModePropertiesKHR( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
11847                                    DisplayModePropertiesKHRAllocator & displayModePropertiesKHRAllocator,
11848                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11849 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11850 
11851     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11852     VULKAN_HPP_NODISCARD Result
11853                          createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR                       display,
11854                                                const VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR * pCreateInfo,
11855                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
11856                                                VULKAN_HPP_NAMESPACE::DisplayModeKHR *                 pMode,
11857                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11858 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11859     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11860     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayModeKHR>::type
11861       createDisplayModeKHR( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
11862                             const DisplayModeCreateInfoKHR &    createInfo,
11863                             Optional<const AllocationCallbacks> allocator
11864                                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11865                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11866 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
11867     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11868     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
11869       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayModeKHR, Dispatch>>::type
11870       createDisplayModeKHRUnique( VULKAN_HPP_NAMESPACE::DisplayKHR    display,
11871                                   const DisplayModeCreateInfoKHR &    createInfo,
11872                                   Optional<const AllocationCallbacks> allocator
11873                                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
11874                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11875 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
11876 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11877 
11878     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11879     VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR(
11880       VULKAN_HPP_NAMESPACE::DisplayModeKHR                mode,
11881       uint32_t                                            planeIndex,
11882       VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR * pCapabilities,
11883       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11884 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11885     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11886     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
11887       typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>::type
11888       getDisplayPlaneCapabilitiesKHR( VULKAN_HPP_NAMESPACE::DisplayModeKHR mode,
11889                                       uint32_t                             planeIndex,
11890                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11891 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11892 
11893 #if defined( VK_USE_PLATFORM_XLIB_KHR )
11894     //=== VK_KHR_xlib_surface ===
11895 
11896     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11897     Bool32 getXlibPresentationSupportKHR( uint32_t         queueFamilyIndex,
11898                                           Display *        dpy,
11899                                           VisualID         visualID,
11900                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11901       VULKAN_HPP_NOEXCEPT;
11902 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11903     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11904     Bool32 getXlibPresentationSupportKHR( uint32_t         queueFamilyIndex,
11905                                           Display &        dpy,
11906                                           VisualID         visualID,
11907                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11908       VULKAN_HPP_NOEXCEPT;
11909 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11910 #endif   /*VK_USE_PLATFORM_XLIB_KHR*/
11911 
11912 #if defined( VK_USE_PLATFORM_XCB_KHR )
11913     //=== VK_KHR_xcb_surface ===
11914 
11915     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11916     Bool32 getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,
11917                                          xcb_connection_t * connection,
11918                                          xcb_visualid_t     visual_id,
11919                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11920       VULKAN_HPP_NOEXCEPT;
11921 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11922     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11923     Bool32 getXcbPresentationSupportKHR( uint32_t           queueFamilyIndex,
11924                                          xcb_connection_t & connection,
11925                                          xcb_visualid_t     visual_id,
11926                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11927       VULKAN_HPP_NOEXCEPT;
11928 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11929 #endif   /*VK_USE_PLATFORM_XCB_KHR*/
11930 
11931 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
11932     //=== VK_KHR_wayland_surface ===
11933 
11934     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11935     Bool32 getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,
11936                                              struct wl_display * display,
11937                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11938       VULKAN_HPP_NOEXCEPT;
11939 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11940     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11941     Bool32 getWaylandPresentationSupportKHR( uint32_t            queueFamilyIndex,
11942                                              struct wl_display & display,
11943                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11944       VULKAN_HPP_NOEXCEPT;
11945 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11946 #endif   /*VK_USE_PLATFORM_WAYLAND_KHR*/
11947 
11948 #if defined( VK_USE_PLATFORM_WIN32_KHR )
11949     //=== VK_KHR_win32_surface ===
11950 
11951     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11952     Bool32 getWin32PresentationSupportKHR( uint32_t         queueFamilyIndex,
11953                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
11954       VULKAN_HPP_NOEXCEPT;
11955 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
11956 
11957 #if defined( VK_ENABLE_BETA_EXTENSIONS )
11958     //=== VK_KHR_video_queue ===
11959 
11960     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11961     VULKAN_HPP_NODISCARD Result
11962                          getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileKHR * pVideoProfile,
11963                                                   VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR *  pCapabilities,
11964                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11965 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11966     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11967     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>::type
11968       getVideoCapabilitiesKHR( const VideoProfileKHR & videoProfile,
11969                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11970     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11971     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
11972       getVideoCapabilitiesKHR( const VideoProfileKHR & videoProfile,
11973                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11974 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
11975 
11976     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11977     VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR(
11978       const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
11979       uint32_t *                                                     pVideoFormatPropertyCount,
11980       VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR *               pVideoFormatProperties,
11981       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
11982 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
11983     template <typename VideoFormatPropertiesKHRAllocator = std::allocator<VideoFormatPropertiesKHR>,
11984               typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
11985     VULKAN_HPP_NODISCARD
11986       typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
11987       getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
11988                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11989     template <
11990       typename VideoFormatPropertiesKHRAllocator = std::allocator<VideoFormatPropertiesKHR>,
11991       typename Dispatch                          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
11992       typename B                                 = VideoFormatPropertiesKHRAllocator,
11993       typename std::enable_if<std::is_same<typename B::value_type, VideoFormatPropertiesKHR>::value, int>::type = 0>
11994     VULKAN_HPP_NODISCARD
11995       typename ResultValueType<std::vector<VideoFormatPropertiesKHR, VideoFormatPropertiesKHRAllocator>>::type
11996       getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo,
11997                                    VideoFormatPropertiesKHRAllocator &      videoFormatPropertiesKHRAllocator,
11998                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
11999 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12000 #endif   /*VK_ENABLE_BETA_EXTENSIONS*/
12001 
12002     //=== VK_NV_external_memory_capabilities ===
12003 
12004     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12005     VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV(
12006       VULKAN_HPP_NAMESPACE::Format                            format,
12007       VULKAN_HPP_NAMESPACE::ImageType                         type,
12008       VULKAN_HPP_NAMESPACE::ImageTiling                       tiling,
12009       VULKAN_HPP_NAMESPACE::ImageUsageFlags                   usage,
12010       VULKAN_HPP_NAMESPACE::ImageCreateFlags                  flags,
12011       VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV   externalHandleType,
12012       VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV * pExternalImageFormatProperties,
12013       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12014 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12015     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12016     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
12017       typename ResultValueType<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>::type
12018       getExternalImageFormatPropertiesNV(
12019         VULKAN_HPP_NAMESPACE::Format           format,
12020         VULKAN_HPP_NAMESPACE::ImageType        type,
12021         VULKAN_HPP_NAMESPACE::ImageTiling      tiling,
12022         VULKAN_HPP_NAMESPACE::ImageUsageFlags  usage,
12023         VULKAN_HPP_NAMESPACE::ImageCreateFlags flags          VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12024         VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12025         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12026 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12027 
12028     //=== VK_KHR_get_physical_device_properties2 ===
12029 
12030     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12031     void getFeatures2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 * pFeatures,
12032                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12033 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12034     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12035     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2
12036                          getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12037     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12038     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12039                          getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12040 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12041 
12042     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12043     void getProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 * pProperties,
12044                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12045 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12046     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12047     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2
12048                          getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12049     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12050     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12051                          getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12052 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12053 
12054     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12055     void
12056       getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format              format,
12057                                VULKAN_HPP_NAMESPACE::FormatProperties2 * pFormatProperties,
12058                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12059 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12060     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12061     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2
12062                          getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format,
12063                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12064     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12065     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12066                          getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format,
12067                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12068 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12069 
12070     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12071     VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR(
12072       const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
12073       VULKAN_HPP_NAMESPACE::ImageFormatProperties2 *               pImageFormatProperties,
12074       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12075 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12076     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12077     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>::type
12078       getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
12079                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12080     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12081     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
12082       getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo,
12083                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12084 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12085 
12086     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12087     void getQueueFamilyProperties2KHR( uint32_t *                                     pQueueFamilyPropertyCount,
12088                                        VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 * pQueueFamilyProperties,
12089                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12090       VULKAN_HPP_NOEXCEPT;
12091 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12092     template <typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
12093               typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12094     VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
12095                          getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12096     template <
12097       typename QueueFamilyProperties2Allocator = std::allocator<QueueFamilyProperties2>,
12098       typename Dispatch                        = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12099       typename B                               = QueueFamilyProperties2Allocator,
12100       typename std::enable_if<std::is_same<typename B::value_type, QueueFamilyProperties2>::value, int>::type = 0>
12101     VULKAN_HPP_NODISCARD std::vector<QueueFamilyProperties2, QueueFamilyProperties2Allocator>
12102                          getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator & queueFamilyProperties2Allocator,
12103                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12104     template <typename StructureChain,
12105               typename StructureChainAllocator = std::allocator<StructureChain>,
12106               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12107     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
12108                          getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12109     template <typename StructureChain,
12110               typename StructureChainAllocator = std::allocator<StructureChain>,
12111               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12112               typename B                       = StructureChainAllocator,
12113               typename std::enable_if<std::is_same<typename B::value_type, StructureChain>::value, int>::type = 0>
12114     VULKAN_HPP_NODISCARD std::vector<StructureChain, StructureChainAllocator>
12115                          getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator,
12116                                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12117 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12118 
12119     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12120     void
12121       getMemoryProperties2KHR( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 * pMemoryProperties,
12122                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12123 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12124     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12125     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
12126                          getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12127     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12128     VULKAN_HPP_NODISCARD StructureChain<X, Y, Z...>
12129                          getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12130 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12131 
12132     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12133     void getSparseImageFormatProperties2KHR(
12134       const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
12135       uint32_t *                                                         pPropertyCount,
12136       VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 *               pProperties,
12137       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12138 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12139     template <typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
12140               typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12141     VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
12142                          getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
12143                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12144     template <
12145       typename SparseImageFormatProperties2Allocator = std::allocator<SparseImageFormatProperties2>,
12146       typename Dispatch                              = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12147       typename B                                     = SparseImageFormatProperties2Allocator,
12148       typename std::enable_if<std::is_same<typename B::value_type, SparseImageFormatProperties2>::value, int>::type = 0>
12149     VULKAN_HPP_NODISCARD std::vector<SparseImageFormatProperties2, SparseImageFormatProperties2Allocator>
12150                          getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo,
12151                                                              SparseImageFormatProperties2Allocator & sparseImageFormatProperties2Allocator,
12152                                                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12153 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12154 
12155     //=== VK_KHR_external_memory_capabilities ===
12156 
12157     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12158     void getExternalBufferPropertiesKHR(
12159       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
12160       VULKAN_HPP_NAMESPACE::ExternalBufferProperties *               pExternalBufferProperties,
12161       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12162 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12163     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12164     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties getExternalBufferPropertiesKHR(
12165       const PhysicalDeviceExternalBufferInfo & externalBufferInfo,
12166       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12167 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12168 
12169     //=== VK_KHR_external_semaphore_capabilities ===
12170 
12171     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12172     void getExternalSemaphorePropertiesKHR(
12173       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
12174       VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties *               pExternalSemaphoreProperties,
12175       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12176 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12177     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12178     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR(
12179       const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo,
12180       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12181 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12182 
12183     //=== VK_EXT_direct_mode_display ===
12184 
12185 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12186     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12187     Result releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
12188                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12189 #else
12190     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12191     typename ResultValueType<void>::type
12192       releaseDisplayEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
12193                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12194 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12195 
12196 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
12197     //=== VK_EXT_acquire_xlib_display ===
12198 
12199     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12200     VULKAN_HPP_NODISCARD Result
12201                          acquireXlibDisplayEXT( Display *                        dpy,
12202                                                 VULKAN_HPP_NAMESPACE::DisplayKHR display,
12203                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12204 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12205     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12206     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12207       acquireXlibDisplayEXT( Display &                        dpy,
12208                              VULKAN_HPP_NAMESPACE::DisplayKHR display,
12209                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12210 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12211 
12212     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12213     VULKAN_HPP_NODISCARD Result
12214                          getRandROutputDisplayEXT( Display *                          dpy,
12215                                                    RROutput                           rrOutput,
12216                                                    VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
12217                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12218 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12219     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12220     typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type getRandROutputDisplayEXT(
12221       Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12222 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
12223     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12224     VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
12225       getRandROutputDisplayEXTUnique( Display &        dpy,
12226                                       RROutput         rrOutput,
12227                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12228 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
12229 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12230 #endif     /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
12231 
12232     //=== VK_EXT_display_surface_counter ===
12233 
12234     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12235     VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT(
12236       VULKAN_HPP_NAMESPACE::SurfaceKHR                surface,
12237       VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT * pSurfaceCapabilities,
12238       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12239 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12240     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12241     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
12242       typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>::type
12243       getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface,
12244                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12245 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12246 
12247     //=== VK_KHR_external_fence_capabilities ===
12248 
12249     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12250     void getExternalFencePropertiesKHR(
12251       const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
12252       VULKAN_HPP_NAMESPACE::ExternalFenceProperties *               pExternalFenceProperties,
12253       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12254 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12255     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12256     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties getExternalFencePropertiesKHR(
12257       const PhysicalDeviceExternalFenceInfo & externalFenceInfo,
12258       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12259 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12260 
12261     //=== VK_KHR_performance_query ===
12262 
12263     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12264     VULKAN_HPP_NODISCARD Result enumerateQueueFamilyPerformanceQueryCountersKHR(
12265       uint32_t                                                 queueFamilyIndex,
12266       uint32_t *                                               pCounterCount,
12267       VULKAN_HPP_NAMESPACE::PerformanceCounterKHR *            pCounters,
12268       VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR * pCounterDescriptions,
12269       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12270 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12271     template <typename Allocator = std::allocator<PerformanceCounterDescriptionKHR>,
12272               typename Dispatch  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12273     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR, Allocator>>::type
12274       enumerateQueueFamilyPerformanceQueryCountersKHR(
12275         uint32_t                                                        queueFamilyIndex,
12276         ArrayProxy<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> const & counters,
12277         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12278     template <typename Allocator                 = std::allocator<PerformanceCounterDescriptionKHR>,
12279               typename Dispatch                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12280               typename B                         = Allocator,
12281               typename std::enable_if<std::is_same<typename B::value_type, PerformanceCounterDescriptionKHR>::value,
12282                                       int>::type = 0>
12283     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PerformanceCounterDescriptionKHR, Allocator>>::type
12284       enumerateQueueFamilyPerformanceQueryCountersKHR(
12285         uint32_t                                                        queueFamilyIndex,
12286         ArrayProxy<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> const & counters,
12287         Allocator const &                                               vectorAllocator,
12288         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12289     template <typename PerformanceCounterKHRAllocator            = std::allocator<PerformanceCounterKHR>,
12290               typename PerformanceCounterDescriptionKHRAllocator = std::allocator<PerformanceCounterDescriptionKHR>,
12291               typename Dispatch                                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12292     VULKAN_HPP_NODISCARD typename ResultValueType<
12293       std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
12294                 std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
12295       enumerateQueueFamilyPerformanceQueryCountersKHR(
12296         uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12297     template <typename PerformanceCounterKHRAllocator            = std::allocator<PerformanceCounterKHR>,
12298               typename PerformanceCounterDescriptionKHRAllocator = std::allocator<PerformanceCounterDescriptionKHR>,
12299               typename Dispatch                                  = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12300               typename B1                                        = PerformanceCounterKHRAllocator,
12301               typename B2                                        = PerformanceCounterDescriptionKHRAllocator,
12302               typename std::enable_if<std::is_same<typename B1::value_type, PerformanceCounterKHR>::value &&
12303                                         std::is_same<typename B2::value_type, PerformanceCounterDescriptionKHR>::value,
12304                                       int>::type                 = 0>
12305     VULKAN_HPP_NODISCARD typename ResultValueType<
12306       std::pair<std::vector<PerformanceCounterKHR, PerformanceCounterKHRAllocator>,
12307                 std::vector<PerformanceCounterDescriptionKHR, PerformanceCounterDescriptionKHRAllocator>>>::type
12308       enumerateQueueFamilyPerformanceQueryCountersKHR(
12309         uint32_t                                    queueFamilyIndex,
12310         PerformanceCounterKHRAllocator &            performanceCounterKHRAllocator,
12311         PerformanceCounterDescriptionKHRAllocator & performanceCounterDescriptionKHRAllocator,
12312         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12313 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12314 
12315     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12316     void getQueueFamilyPerformanceQueryPassesKHR(
12317       const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
12318       uint32_t *                                                      pNumPasses,
12319       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12320 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12321     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12322     VULKAN_HPP_NODISCARD uint32_t getQueueFamilyPerformanceQueryPassesKHR(
12323       const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo,
12324       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12325 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12326 
12327     //=== VK_KHR_get_surface_capabilities2 ===
12328 
12329     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12330     VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR(
12331       const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
12332       VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR *             pSurfaceCapabilities,
12333       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12334 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12335     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12336     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
12337       typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>::type
12338       getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
12339                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12340     template <typename X, typename Y, typename... Z, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12341     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<StructureChain<X, Y, Z...>>::type
12342       getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
12343                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12344 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12345 
12346     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12347     VULKAN_HPP_NODISCARD Result
12348                          getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
12349                                                 uint32_t *                                                  pSurfaceFormatCount,
12350                                                 VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR *                   pSurfaceFormats,
12351                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12352 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12353     template <typename SurfaceFormat2KHRAllocator = std::allocator<SurfaceFormat2KHR>,
12354               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12355     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
12356       getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
12357                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12358     template <typename SurfaceFormat2KHRAllocator = std::allocator<SurfaceFormat2KHR>,
12359               typename Dispatch                   = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12360               typename B                          = SurfaceFormat2KHRAllocator,
12361               typename std::enable_if<std::is_same<typename B::value_type, SurfaceFormat2KHR>::value, int>::type = 0>
12362     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<SurfaceFormat2KHR, SurfaceFormat2KHRAllocator>>::type
12363       getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
12364                              SurfaceFormat2KHRAllocator &          surfaceFormat2KHRAllocator,
12365                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12366 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12367 
12368     //=== VK_KHR_get_display_properties2 ===
12369 
12370     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12371     VULKAN_HPP_NODISCARD Result
12372                          getDisplayProperties2KHR( uint32_t *                                    pPropertyCount,
12373                                                    VULKAN_HPP_NAMESPACE::DisplayProperties2KHR * pProperties,
12374                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12375 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12376     template <typename DisplayProperties2KHRAllocator = std::allocator<DisplayProperties2KHR>,
12377               typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12378     VULKAN_HPP_NODISCARD
12379       typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
12380       getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12381     template <
12382       typename DisplayProperties2KHRAllocator = std::allocator<DisplayProperties2KHR>,
12383       typename Dispatch                       = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12384       typename B                              = DisplayProperties2KHRAllocator,
12385       typename std::enable_if<std::is_same<typename B::value_type, DisplayProperties2KHR>::value, int>::type = 0>
12386     VULKAN_HPP_NODISCARD
12387       typename ResultValueType<std::vector<DisplayProperties2KHR, DisplayProperties2KHRAllocator>>::type
12388       getDisplayProperties2KHR( DisplayProperties2KHRAllocator & displayProperties2KHRAllocator,
12389                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12390 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12391 
12392     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12393     VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR(
12394       uint32_t *                                         pPropertyCount,
12395       VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR * pProperties,
12396       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12397 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12398     template <typename DisplayPlaneProperties2KHRAllocator = std::allocator<DisplayPlaneProperties2KHR>,
12399               typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12400     VULKAN_HPP_NODISCARD
12401       typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
12402       getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12403     template <
12404       typename DisplayPlaneProperties2KHRAllocator = std::allocator<DisplayPlaneProperties2KHR>,
12405       typename Dispatch                            = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12406       typename B                                   = DisplayPlaneProperties2KHRAllocator,
12407       typename std::enable_if<std::is_same<typename B::value_type, DisplayPlaneProperties2KHR>::value, int>::type = 0>
12408     VULKAN_HPP_NODISCARD
12409       typename ResultValueType<std::vector<DisplayPlaneProperties2KHR, DisplayPlaneProperties2KHRAllocator>>::type
12410       getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator & displayPlaneProperties2KHRAllocator,
12411                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12412 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12413 
12414     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12415     VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR(
12416       VULKAN_HPP_NAMESPACE::DisplayKHR                  display,
12417       uint32_t *                                        pPropertyCount,
12418       VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR * pProperties,
12419       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12420 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12421     template <typename DisplayModeProperties2KHRAllocator = std::allocator<DisplayModeProperties2KHR>,
12422               typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12423     VULKAN_HPP_NODISCARD
12424       typename ResultValueType<std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
12425       getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR display,
12426                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12427     template <
12428       typename DisplayModeProperties2KHRAllocator = std::allocator<DisplayModeProperties2KHR>,
12429       typename Dispatch                           = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12430       typename B                                  = DisplayModeProperties2KHRAllocator,
12431       typename std::enable_if<std::is_same<typename B::value_type, DisplayModeProperties2KHR>::value, int>::type = 0>
12432     VULKAN_HPP_NODISCARD
12433       typename ResultValueType<std::vector<DisplayModeProperties2KHR, DisplayModeProperties2KHRAllocator>>::type
12434       getDisplayModeProperties2KHR( VULKAN_HPP_NAMESPACE::DisplayKHR     display,
12435                                     DisplayModeProperties2KHRAllocator & displayModeProperties2KHRAllocator,
12436                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12437 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12438 
12439     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12440     VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilities2KHR(
12441       const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR *   pDisplayPlaneInfo,
12442       VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR * pCapabilities,
12443       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12444 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12445     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12446     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
12447       typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>::type
12448       getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo,
12449                                        Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12450 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12451 
12452     //=== VK_EXT_sample_locations ===
12453 
12454     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12455     void getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits        samples,
12456                                       VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT * pMultisampleProperties,
12457                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12458       VULKAN_HPP_NOEXCEPT;
12459 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12460     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12461     VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT getMultisamplePropertiesEXT(
12462       VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
12463       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12464 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12465 
12466     //=== VK_EXT_calibrated_timestamps ===
12467 
12468     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12469     VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT(
12470       uint32_t *                            pTimeDomainCount,
12471       VULKAN_HPP_NAMESPACE::TimeDomainEXT * pTimeDomains,
12472       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12473 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12474     template <typename TimeDomainEXTAllocator = std::allocator<TimeDomainEXT>,
12475               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12476     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TimeDomainEXT, TimeDomainEXTAllocator>>::type
12477       getCalibrateableTimeDomainsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12478     template <typename TimeDomainEXTAllocator = std::allocator<TimeDomainEXT>,
12479               typename Dispatch               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12480               typename B                      = TimeDomainEXTAllocator,
12481               typename std::enable_if<std::is_same<typename B::value_type, TimeDomainEXT>::value, int>::type = 0>
12482     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<TimeDomainEXT, TimeDomainEXTAllocator>>::type
12483       getCalibrateableTimeDomainsEXT( TimeDomainEXTAllocator & timeDomainEXTAllocator,
12484                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12485 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12486 
12487     //=== VK_KHR_fragment_shading_rate ===
12488 
12489     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12490     VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR(
12491       uint32_t *                                                   pFragmentShadingRateCount,
12492       VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates,
12493       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12494 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12495     template <
12496       typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<PhysicalDeviceFragmentShadingRateKHR>,
12497       typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12498     VULKAN_HPP_NODISCARD typename ResultValueType<
12499       std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
12500       getFragmentShadingRatesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12501     template <
12502       typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator<PhysicalDeviceFragmentShadingRateKHR>,
12503       typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12504       typename B                                             = PhysicalDeviceFragmentShadingRateKHRAllocator,
12505       typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceFragmentShadingRateKHR>::value,
12506                               int>::type                     = 0>
12507     VULKAN_HPP_NODISCARD typename ResultValueType<
12508       std::vector<PhysicalDeviceFragmentShadingRateKHR, PhysicalDeviceFragmentShadingRateKHRAllocator>>::type
12509       getFragmentShadingRatesKHR(
12510         PhysicalDeviceFragmentShadingRateKHRAllocator & physicalDeviceFragmentShadingRateKHRAllocator,
12511         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12512 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12513 
12514     //=== VK_EXT_tooling_info ===
12515 
12516     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12517     VULKAN_HPP_NODISCARD Result
12518                          getToolPropertiesEXT( uint32_t *                                              pToolCount,
12519                                                VULKAN_HPP_NAMESPACE::PhysicalDeviceToolPropertiesEXT * pToolProperties,
12520                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12521 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12522     template <typename PhysicalDeviceToolPropertiesEXTAllocator = std::allocator<PhysicalDeviceToolPropertiesEXT>,
12523               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12524     VULKAN_HPP_NODISCARD typename ResultValueType<
12525       std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator>>::type
12526       getToolPropertiesEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12527     template <typename PhysicalDeviceToolPropertiesEXTAllocator = std::allocator<PhysicalDeviceToolPropertiesEXT>,
12528               typename Dispatch                                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12529               typename B                                        = PhysicalDeviceToolPropertiesEXTAllocator,
12530               typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceToolPropertiesEXT>::value,
12531                                       int>::type                = 0>
12532     VULKAN_HPP_NODISCARD typename ResultValueType<
12533       std::vector<PhysicalDeviceToolPropertiesEXT, PhysicalDeviceToolPropertiesEXTAllocator>>::type
12534       getToolPropertiesEXT( PhysicalDeviceToolPropertiesEXTAllocator & physicalDeviceToolPropertiesEXTAllocator,
12535                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12536 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12537 
12538     //=== VK_NV_cooperative_matrix ===
12539 
12540     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12541     VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV(
12542       uint32_t *                                            pPropertyCount,
12543       VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV * pProperties,
12544       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12545 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12546     template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<CooperativeMatrixPropertiesNV>,
12547               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12548     VULKAN_HPP_NODISCARD
12549       typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
12550       getCooperativeMatrixPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12551     template <typename CooperativeMatrixPropertiesNVAllocator = std::allocator<CooperativeMatrixPropertiesNV>,
12552               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12553               typename B                                      = CooperativeMatrixPropertiesNVAllocator,
12554               typename std::enable_if<std::is_same<typename B::value_type, CooperativeMatrixPropertiesNV>::value,
12555                                       int>::type              = 0>
12556     VULKAN_HPP_NODISCARD
12557       typename ResultValueType<std::vector<CooperativeMatrixPropertiesNV, CooperativeMatrixPropertiesNVAllocator>>::type
12558       getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator & cooperativeMatrixPropertiesNVAllocator,
12559                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12560 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12561 
12562     //=== VK_NV_coverage_reduction_mode ===
12563 
12564     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12565     VULKAN_HPP_NODISCARD Result getSupportedFramebufferMixedSamplesCombinationsNV(
12566       uint32_t *                                                   pCombinationCount,
12567       VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV * pCombinations,
12568       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12569 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12570     template <
12571       typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<FramebufferMixedSamplesCombinationNV>,
12572       typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12573     VULKAN_HPP_NODISCARD typename ResultValueType<
12574       std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
12575       getSupportedFramebufferMixedSamplesCombinationsNV(
12576         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12577     template <
12578       typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator<FramebufferMixedSamplesCombinationNV>,
12579       typename Dispatch                                      = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12580       typename B                                             = FramebufferMixedSamplesCombinationNVAllocator,
12581       typename std::enable_if<std::is_same<typename B::value_type, FramebufferMixedSamplesCombinationNV>::value,
12582                               int>::type                     = 0>
12583     VULKAN_HPP_NODISCARD typename ResultValueType<
12584       std::vector<FramebufferMixedSamplesCombinationNV, FramebufferMixedSamplesCombinationNVAllocator>>::type
12585       getSupportedFramebufferMixedSamplesCombinationsNV(
12586         FramebufferMixedSamplesCombinationNVAllocator & framebufferMixedSamplesCombinationNVAllocator,
12587         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12588 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12589 
12590 #if defined( VK_USE_PLATFORM_WIN32_KHR )
12591     //=== VK_EXT_full_screen_exclusive ===
12592 
12593     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12594     VULKAN_HPP_NODISCARD Result getSurfacePresentModes2EXT(
12595       const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
12596       uint32_t *                                                  pPresentModeCount,
12597       VULKAN_HPP_NAMESPACE::PresentModeKHR *                      pPresentModes,
12598       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12599 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12600     template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
12601               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12602     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
12603       getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
12604                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12605     template <typename PresentModeKHRAllocator = std::allocator<PresentModeKHR>,
12606               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12607               typename B                       = PresentModeKHRAllocator,
12608               typename std::enable_if<std::is_same<typename B::value_type, PresentModeKHR>::value, int>::type = 0>
12609     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PresentModeKHR, PresentModeKHRAllocator>>::type
12610       getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo,
12611                                   PresentModeKHRAllocator &             presentModeKHRAllocator,
12612                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12613 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12614 #endif   /*VK_USE_PLATFORM_WIN32_KHR*/
12615 
12616     //=== VK_EXT_acquire_drm_display ===
12617 
12618 #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12619     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12620     VULKAN_HPP_NODISCARD Result
12621                          acquireDrmDisplayEXT( int32_t                          drmFd,
12622                                                VULKAN_HPP_NAMESPACE::DisplayKHR display,
12623                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12624 #else
12625     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12626     typename ResultValueType<void>::type
12627          acquireDrmDisplayEXT( int32_t                          drmFd,
12628                                VULKAN_HPP_NAMESPACE::DisplayKHR display,
12629                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12630 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12631 
12632     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12633     VULKAN_HPP_NODISCARD Result
12634                          getDrmDisplayEXT( int32_t                            drmFd,
12635                                            uint32_t                           connectorId,
12636                                            VULKAN_HPP_NAMESPACE::DisplayKHR * display,
12637                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12638 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12639     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12640     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
12641       getDrmDisplayEXT( int32_t          drmFd,
12642                         uint32_t         connectorId,
12643                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12644 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12645     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12646     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
12647       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
12648       getDrmDisplayEXTUnique( int32_t          drmFd,
12649                               uint32_t         connectorId,
12650                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12651 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
12652 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12653 
12654 #if defined( VK_USE_PLATFORM_WIN32_KHR )
12655     //=== VK_NV_acquire_winrt_display ===
12656 
12657 #  ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
12658     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12659     VULKAN_HPP_NODISCARD Result
12660                          acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
12661                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12662 #  else
12663     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12664     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
12665       acquireWinrtDisplayNV( VULKAN_HPP_NAMESPACE::DisplayKHR display,
12666                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12667 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12668 
12669     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12670     VULKAN_HPP_NODISCARD Result
12671                          getWinrtDisplayNV( uint32_t                           deviceRelativeId,
12672                                             VULKAN_HPP_NAMESPACE::DisplayKHR * pDisplay,
12673                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12674 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12675     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12676     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::DisplayKHR>::type
12677       getWinrtDisplayNV( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12678 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
12679     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12680     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
12681       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DisplayKHR, Dispatch>>::type
12682       getWinrtDisplayNVUnique( uint32_t         deviceRelativeId,
12683                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12684 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
12685 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12686 #endif     /*VK_USE_PLATFORM_WIN32_KHR*/
12687 
12688 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
12689     //=== VK_EXT_directfb_surface ===
12690 
12691     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12692     Bool32 getDirectFBPresentationSupportEXT( uint32_t         queueFamilyIndex,
12693                                               IDirectFB *      dfb,
12694                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12695       VULKAN_HPP_NOEXCEPT;
12696 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12697     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12698     Bool32 getDirectFBPresentationSupportEXT( uint32_t         queueFamilyIndex,
12699                                               IDirectFB &      dfb,
12700                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12701       VULKAN_HPP_NOEXCEPT;
12702 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12703 #endif   /*VK_USE_PLATFORM_DIRECTFB_EXT*/
12704 
12705 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
12706     //=== VK_QNX_screen_surface ===
12707 
12708     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12709     Bool32 getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,
12710                                             struct _screen_window * window,
12711                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12712       VULKAN_HPP_NOEXCEPT;
12713 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12714     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12715     Bool32 getScreenPresentationSupportQNX( uint32_t                queueFamilyIndex,
12716                                             struct _screen_window & window,
12717                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
12718       VULKAN_HPP_NOEXCEPT;
12719 #  endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12720 #endif   /*VK_USE_PLATFORM_SCREEN_QNX*/
12721 
operator VkPhysicalDevice() const12722     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT
12723     {
12724       return m_physicalDevice;
12725     }
12726 
operator bool() const12727     explicit operator bool() const VULKAN_HPP_NOEXCEPT
12728     {
12729       return m_physicalDevice != VK_NULL_HANDLE;
12730     }
12731 
operator !() const12732     bool operator!() const VULKAN_HPP_NOEXCEPT
12733     {
12734       return m_physicalDevice == VK_NULL_HANDLE;
12735     }
12736 
12737   private:
12738     VkPhysicalDevice m_physicalDevice = {};
12739   };
12740   static_assert( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevice ) == sizeof( VkPhysicalDevice ),
12741                  "handle and wrapper have different size!" );
12742 
12743   template <>
12744   struct VULKAN_HPP_DEPRECATED(
12745     "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::ePhysicalDevice>
12746   {
12747     using type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
12748   };
12749 
12750   template <>
12751   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice>
12752   {
12753     using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
12754   };
12755 
12756   template <>
12757   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
12758                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice>
12759   {
12760     using Type = VULKAN_HPP_NAMESPACE::PhysicalDevice;
12761   };
12762 
12763   template <>
12764   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::PhysicalDevice>
12765   {
12766     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
12767   };
12768 
12769 #ifndef VULKAN_HPP_NO_SMART_HANDLE
12770   class Instance;
12771   template <typename Dispatch>
12772   class UniqueHandleTraits<DebugReportCallbackEXT, Dispatch>
12773   {
12774   public:
12775     using deleter = ObjectDestroy<Instance, Dispatch>;
12776   };
12777   using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
12778   template <typename Dispatch>
12779   class UniqueHandleTraits<DebugUtilsMessengerEXT, Dispatch>
12780   {
12781   public:
12782     using deleter = ObjectDestroy<Instance, Dispatch>;
12783   };
12784   using UniqueDebugUtilsMessengerEXT = UniqueHandle<DebugUtilsMessengerEXT, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
12785   template <typename Dispatch>
12786   class UniqueHandleTraits<SurfaceKHR, Dispatch>
12787   {
12788   public:
12789     using deleter = ObjectDestroy<Instance, Dispatch>;
12790   };
12791   using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
12792 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
12793 
12794   class Instance
12795   {
12796   public:
12797     using CType = VkInstance;
12798 
12799     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType =
12800       VULKAN_HPP_NAMESPACE::ObjectType::eInstance;
12801     static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType =
12802       VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance;
12803 
12804   public:
12805     VULKAN_HPP_CONSTEXPR         Instance() = default;
Instance(std::nullptr_t)12806     VULKAN_HPP_CONSTEXPR         Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {}
Instance(VkInstance instance)12807     VULKAN_HPP_TYPESAFE_EXPLICIT Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT : m_instance( instance ) {}
12808 
12809 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
operator =(VkInstance instance)12810     Instance & operator=( VkInstance instance ) VULKAN_HPP_NOEXCEPT
12811     {
12812       m_instance = instance;
12813       return *this;
12814     }
12815 #endif
12816 
operator =(std::nullptr_t)12817     Instance & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
12818     {
12819       m_instance = {};
12820       return *this;
12821     }
12822 
12823 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
12824     auto operator<=>( Instance const & ) const = default;
12825 #else
operator ==(Instance const & rhs) const12826     bool operator==( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
12827     {
12828       return m_instance == rhs.m_instance;
12829     }
12830 
operator !=(Instance const & rhs) const12831     bool operator!=( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
12832     {
12833       return m_instance != rhs.m_instance;
12834     }
12835 
operator <(Instance const & rhs) const12836     bool operator<( Instance const & rhs ) const VULKAN_HPP_NOEXCEPT
12837     {
12838       return m_instance < rhs.m_instance;
12839     }
12840 #endif
12841 
12842     //=== VK_VERSION_1_0 ===
12843 
12844     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12845     void destroy( const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12846                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12847 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12848     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12849     void destroy( Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12850                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12851 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12852 
12853     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12854     VULKAN_HPP_NODISCARD Result
12855                          enumeratePhysicalDevices( uint32_t *                             pPhysicalDeviceCount,
12856                                                    VULKAN_HPP_NAMESPACE::PhysicalDevice * pPhysicalDevices,
12857                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12858 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12859     template <typename PhysicalDeviceAllocator = std::allocator<PhysicalDevice>,
12860               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12861     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type
12862       enumeratePhysicalDevices( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12863     template <typename PhysicalDeviceAllocator = std::allocator<PhysicalDevice>,
12864               typename Dispatch                = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12865               typename B                       = PhysicalDeviceAllocator,
12866               typename std::enable_if<std::is_same<typename B::value_type, PhysicalDevice>::value, int>::type = 0>
12867     VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<PhysicalDevice, PhysicalDeviceAllocator>>::type
12868       enumeratePhysicalDevices( PhysicalDeviceAllocator & physicalDeviceAllocator,
12869                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12870 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12871 
12872     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12873     PFN_vkVoidFunction
12874       getProcAddr( const char *     pName,
12875                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12876 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12877     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12878     PFN_vkVoidFunction
12879       getProcAddr( const std::string & name,
12880                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12881 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12882 
12883     //=== VK_VERSION_1_1 ===
12884 
12885     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12886     VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups(
12887       uint32_t *                                            pPhysicalDeviceGroupCount,
12888       VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
12889       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12890 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12891     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
12892               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12893     VULKAN_HPP_NODISCARD
12894       typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
12895       enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12896     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
12897               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
12898               typename B                                      = PhysicalDeviceGroupPropertiesAllocator,
12899               typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value,
12900                                       int>::type              = 0>
12901     VULKAN_HPP_NODISCARD
12902       typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
12903       enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
12904                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12905 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12906 
12907     //=== VK_KHR_surface ===
12908 
12909     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12910     void destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,
12911                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12912                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12913 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12914     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12915     void
12916       destroySurfaceKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
12917                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12918                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12919 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12920 
12921     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12922     void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR                  surface,
12923                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
12924                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12925 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12926     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12927     void destroy( VULKAN_HPP_NAMESPACE::SurfaceKHR    surface,
12928                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12929                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12930 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12931 
12932     //=== VK_KHR_display ===
12933 
12934     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12935     VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR(
12936       const VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR * pCreateInfo,
12937       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
12938       VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
12939       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12940 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12941     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12942     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
12943       createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo,
12944                                     Optional<const AllocationCallbacks> allocator
12945                                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12946                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12947 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
12948     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12949     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
12950       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
12951       createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo,
12952                                           Optional<const AllocationCallbacks> allocator
12953                                                                               VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12954                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12955 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
12956 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12957 
12958 #if defined( VK_USE_PLATFORM_XLIB_KHR )
12959     //=== VK_KHR_xlib_surface ===
12960 
12961     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12962     VULKAN_HPP_NODISCARD Result
12963                          createXlibSurfaceKHR( const VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR * pCreateInfo,
12964                                                const VULKAN_HPP_NAMESPACE::AllocationCallbacks *      pAllocator,
12965                                                VULKAN_HPP_NAMESPACE::SurfaceKHR *                     pSurface,
12966                                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12967 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12968     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12969     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
12970       createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR &    createInfo,
12971                             Optional<const AllocationCallbacks> allocator
12972                                                                 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12973                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12974 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
12975     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12976     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
12977       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
12978       createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR &    createInfo,
12979                                   Optional<const AllocationCallbacks> allocator
12980                                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
12981                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
12982 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
12983 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
12984 #endif     /*VK_USE_PLATFORM_XLIB_KHR*/
12985 
12986 #if defined( VK_USE_PLATFORM_XCB_KHR )
12987     //=== VK_KHR_xcb_surface ===
12988 
12989     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12990     VULKAN_HPP_NODISCARD Result
12991                          createXcbSurfaceKHR( const VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR * pCreateInfo,
12992                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
12993                                               VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,
12994                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
12995 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
12996     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
12997     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
12998       createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR &     createInfo,
12999                            Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13000                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13001 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13002     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13003     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13004       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13005       createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR &     createInfo,
13006                                  Optional<const AllocationCallbacks> allocator
13007                                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13008                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13009 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13010 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13011 #endif     /*VK_USE_PLATFORM_XCB_KHR*/
13012 
13013 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
13014     //=== VK_KHR_wayland_surface ===
13015 
13016     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13017     VULKAN_HPP_NODISCARD Result
13018                          createWaylandSurfaceKHR( const VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR * pCreateInfo,
13019                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
13020                                                   VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
13021                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13022 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13023     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13024     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13025       createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo,
13026                                Optional<const AllocationCallbacks> allocator
13027                                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13028                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13029 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13030     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13031     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13032       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13033       createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo,
13034                                      Optional<const AllocationCallbacks> allocator
13035                                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13036                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13037 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13038 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13039 #endif     /*VK_USE_PLATFORM_WAYLAND_KHR*/
13040 
13041 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
13042     //=== VK_KHR_android_surface ===
13043 
13044     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13045     VULKAN_HPP_NODISCARD Result
13046                          createAndroidSurfaceKHR( const VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR * pCreateInfo,
13047                                                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks *         pAllocator,
13048                                                   VULKAN_HPP_NAMESPACE::SurfaceKHR *                        pSurface,
13049                                                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13050 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13051     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13052     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13053       createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo,
13054                                Optional<const AllocationCallbacks> allocator
13055                                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13056                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13057 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13058     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13059     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13060       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13061       createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo,
13062                                      Optional<const AllocationCallbacks> allocator
13063                                                                          VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13064                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13065 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13066 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13067 #endif     /*VK_USE_PLATFORM_ANDROID_KHR*/
13068 
13069 #if defined( VK_USE_PLATFORM_WIN32_KHR )
13070     //=== VK_KHR_win32_surface ===
13071 
13072     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13073     VULKAN_HPP_NODISCARD Result
13074                          createWin32SurfaceKHR( const VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR * pCreateInfo,
13075                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
13076                                                 VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
13077                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13078 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13079     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13080     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13081       createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR &   createInfo,
13082                              Optional<const AllocationCallbacks> allocator
13083                                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13084                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13085 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13086     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13087     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13088       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13089       createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR &   createInfo,
13090                                    Optional<const AllocationCallbacks> allocator
13091                                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13092                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13093 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13094 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13095 #endif     /*VK_USE_PLATFORM_WIN32_KHR*/
13096 
13097     //=== VK_EXT_debug_report ===
13098 
13099     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13100     VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT(
13101       const VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT * pCreateInfo,
13102       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
13103       VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT *                 pCallback,
13104       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13105 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13106     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13107     typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>::type createDebugReportCallbackEXT(
13108       const DebugReportCallbackCreateInfoEXT & createInfo,
13109       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13110       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13111 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
13112     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13113     VULKAN_HPP_INLINE
13114       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT, Dispatch>>::type
13115       createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo,
13116                                           Optional<const AllocationCallbacks>      allocator
13117                                                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13118                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13119 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13120 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13121 
13122     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13123     void destroyDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,
13124                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13125                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
13126       VULKAN_HPP_NOEXCEPT;
13127 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13128     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13129     void destroyDebugReportCallbackEXT(
13130       VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
13131       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13132       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13133 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13134 
13135     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13136     void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT      callback,
13137                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13138                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13139 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13140     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13141     void destroy( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback,
13142                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13143                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13144 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13145 
13146     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13147     void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
13148                                 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,
13149                                 uint64_t                                       object,
13150                                 size_t                                         location,
13151                                 int32_t                                        messageCode,
13152                                 const char *                                   pLayerPrefix,
13153                                 const char *                                   pMessage,
13154                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13155 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13156     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13157     void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT      flags,
13158                                 VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType,
13159                                 uint64_t                                       object,
13160                                 size_t                                         location,
13161                                 int32_t                                        messageCode,
13162                                 const std::string &                            layerPrefix,
13163                                 const std::string &                            message,
13164                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13165 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13166 
13167 #if defined( VK_USE_PLATFORM_GGP )
13168     //=== VK_GGP_stream_descriptor_surface ===
13169 
13170     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13171     VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP(
13172       const VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
13173       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *                  pAllocator,
13174       VULKAN_HPP_NAMESPACE::SurfaceKHR *                                 pSurface,
13175       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13176 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13177     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13178     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13179       createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo,
13180                                         Optional<const AllocationCallbacks>          allocator
13181                                                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13182                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13183 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13184     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13185     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13186       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13187       createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo,
13188                                               Optional<const AllocationCallbacks>          allocator
13189                                                                                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13190                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13191 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13192 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13193 #endif     /*VK_USE_PLATFORM_GGP*/
13194 
13195 #if defined( VK_USE_PLATFORM_VI_NN )
13196     //=== VK_NN_vi_surface ===
13197 
13198     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13199     VULKAN_HPP_NODISCARD Result
13200                          createViSurfaceNN( const VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN * pCreateInfo,
13201                                             const VULKAN_HPP_NAMESPACE::AllocationCallbacks *   pAllocator,
13202                                             VULKAN_HPP_NAMESPACE::SurfaceKHR *                  pSurface,
13203                                             Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13204 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13205     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13206     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13207       createViSurfaceNN( const ViSurfaceCreateInfoNN &       createInfo,
13208                          Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13209                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13210 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13211     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13212     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13213       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13214       createViSurfaceNNUnique( const ViSurfaceCreateInfoNN &       createInfo,
13215                                Optional<const AllocationCallbacks> allocator
13216                                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13217                                Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13218 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13219 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13220 #endif     /*VK_USE_PLATFORM_VI_NN*/
13221 
13222     //=== VK_KHR_device_group_creation ===
13223 
13224     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13225     VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR(
13226       uint32_t *                                            pPhysicalDeviceGroupCount,
13227       VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties,
13228       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13229 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13230     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
13231               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13232     VULKAN_HPP_NODISCARD
13233       typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
13234       enumeratePhysicalDeviceGroupsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13235     template <typename PhysicalDeviceGroupPropertiesAllocator = std::allocator<PhysicalDeviceGroupProperties>,
13236               typename Dispatch                               = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13237               typename B                                      = PhysicalDeviceGroupPropertiesAllocator,
13238               typename std::enable_if<std::is_same<typename B::value_type, PhysicalDeviceGroupProperties>::value,
13239                                       int>::type              = 0>
13240     VULKAN_HPP_NODISCARD
13241       typename ResultValueType<std::vector<PhysicalDeviceGroupProperties, PhysicalDeviceGroupPropertiesAllocator>>::type
13242       enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator & physicalDeviceGroupPropertiesAllocator,
13243                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13244 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13245 
13246 #if defined( VK_USE_PLATFORM_IOS_MVK )
13247     //=== VK_MVK_ios_surface ===
13248 
13249     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13250     VULKAN_HPP_NODISCARD Result
13251                          createIOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK * pCreateInfo,
13252                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks *     pAllocator,
13253                                               VULKAN_HPP_NAMESPACE::SurfaceKHR *                    pSurface,
13254                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13255 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13256     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13257     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13258       createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK &     createInfo,
13259                            Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13260                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13261 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13262     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13263     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13264       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13265       createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK &     createInfo,
13266                                  Optional<const AllocationCallbacks> allocator
13267                                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13268                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13269 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13270 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13271 #endif     /*VK_USE_PLATFORM_IOS_MVK*/
13272 
13273 #if defined( VK_USE_PLATFORM_MACOS_MVK )
13274     //=== VK_MVK_macos_surface ===
13275 
13276     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13277     VULKAN_HPP_NODISCARD Result
13278                          createMacOSSurfaceMVK( const VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK * pCreateInfo,
13279                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
13280                                                 VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
13281                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13282 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13283     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13284     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13285       createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK &   createInfo,
13286                              Optional<const AllocationCallbacks> allocator
13287                                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13288                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13289 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13290     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13291     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13292       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13293       createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK &   createInfo,
13294                                    Optional<const AllocationCallbacks> allocator
13295                                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13296                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13297 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13298 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13299 #endif     /*VK_USE_PLATFORM_MACOS_MVK*/
13300 
13301     //=== VK_EXT_debug_utils ===
13302 
13303     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13304     VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT(
13305       const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT * pCreateInfo,
13306       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *              pAllocator,
13307       VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT *                 pMessenger,
13308       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13309 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13310     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13311     typename ResultValueType<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>::type createDebugUtilsMessengerEXT(
13312       const DebugUtilsMessengerCreateInfoEXT & createInfo,
13313       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13314       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13315 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
13316     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13317     VULKAN_HPP_INLINE
13318       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT, Dispatch>>::type
13319       createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo,
13320                                           Optional<const AllocationCallbacks>      allocator
13321                                                                                    VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13322                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13323 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13324 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13325 
13326     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13327     void destroyDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,
13328                                         const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13329                                         Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
13330       VULKAN_HPP_NOEXCEPT;
13331 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13332     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13333     void destroyDebugUtilsMessengerEXT(
13334       VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
13335       Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13336       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13337 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13338 
13339     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13340     void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT      messenger,
13341                   const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13342                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13343 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13344     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13345     void destroy( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger,
13346                   Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13347                   Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13348 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13349 
13350     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13351     void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT       messageSeverity,
13352                                      VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT              messageTypes,
13353                                      const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT * pCallbackData,
13354                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
13355       VULKAN_HPP_NOEXCEPT;
13356 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13357     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13358     void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
13359                                      VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT        messageTypes,
13360                                      const DebugUtilsMessengerCallbackDataEXT &                 callbackData,
13361                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const
13362       VULKAN_HPP_NOEXCEPT;
13363 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13364 
13365 #if defined( VK_USE_PLATFORM_FUCHSIA )
13366     //=== VK_FUCHSIA_imagepipe_surface ===
13367 
13368     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13369     VULKAN_HPP_NODISCARD Result createImagePipeSurfaceFUCHSIA(
13370       const VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
13371       const VULKAN_HPP_NAMESPACE::AllocationCallbacks *               pAllocator,
13372       VULKAN_HPP_NAMESPACE::SurfaceKHR *                              pSurface,
13373       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13374 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13375     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13376     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13377       createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
13378                                      Optional<const AllocationCallbacks>       allocator
13379                                                                                VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13380                                      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13381 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13382     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13383     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13384       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13385       createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo,
13386                                            Optional<const AllocationCallbacks>       allocator
13387                                                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13388                                            Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13389 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13390 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13391 #endif     /*VK_USE_PLATFORM_FUCHSIA*/
13392 
13393 #if defined( VK_USE_PLATFORM_METAL_EXT )
13394     //=== VK_EXT_metal_surface ===
13395 
13396     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13397     VULKAN_HPP_NODISCARD Result
13398                          createMetalSurfaceEXT( const VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT * pCreateInfo,
13399                                                 const VULKAN_HPP_NAMESPACE::AllocationCallbacks *       pAllocator,
13400                                                 VULKAN_HPP_NAMESPACE::SurfaceKHR *                      pSurface,
13401                                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13402 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13403     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13404     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13405       createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT &   createInfo,
13406                              Optional<const AllocationCallbacks> allocator
13407                                                                  VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13408                              Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13409 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13410     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13411     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13412       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13413       createMetalSurfaceEXTUnique( const MetalSurfaceCreateInfoEXT &   createInfo,
13414                                    Optional<const AllocationCallbacks> allocator
13415                                                                        VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13416                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13417 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13418 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13419 #endif     /*VK_USE_PLATFORM_METAL_EXT*/
13420 
13421     //=== VK_EXT_headless_surface ===
13422 
13423     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13424     VULKAN_HPP_NODISCARD Result
13425                          createHeadlessSurfaceEXT( const VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT * pCreateInfo,
13426                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
13427                                                    VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
13428                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13429 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13430     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13431     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13432       createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo,
13433                                 Optional<const AllocationCallbacks>  allocator
13434                                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13435                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13436 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
13437     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13438     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13439       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13440       createHeadlessSurfaceEXTUnique( const HeadlessSurfaceCreateInfoEXT & createInfo,
13441                                       Optional<const AllocationCallbacks>  allocator
13442                                                                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13443                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13444 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13445 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13446 
13447 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
13448     //=== VK_EXT_directfb_surface ===
13449 
13450     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13451     VULKAN_HPP_NODISCARD Result
13452                          createDirectFBSurfaceEXT( const VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT * pCreateInfo,
13453                                                    const VULKAN_HPP_NAMESPACE::AllocationCallbacks *          pAllocator,
13454                                                    VULKAN_HPP_NAMESPACE::SurfaceKHR *                         pSurface,
13455                                                    Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13456 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13457     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13458     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13459       createDirectFBSurfaceEXT( const DirectFBSurfaceCreateInfoEXT & createInfo,
13460                                 Optional<const AllocationCallbacks>  allocator
13461                                                                      VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13462                                 Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13463 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13464     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13465     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13466       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13467       createDirectFBSurfaceEXTUnique( const DirectFBSurfaceCreateInfoEXT & createInfo,
13468                                       Optional<const AllocationCallbacks>  allocator
13469                                                                            VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13470                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13471 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13472 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13473 #endif     /*VK_USE_PLATFORM_DIRECTFB_EXT*/
13474 
13475 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
13476     //=== VK_QNX_screen_surface ===
13477 
13478     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13479     VULKAN_HPP_NODISCARD Result
13480                          createScreenSurfaceQNX( const VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX * pCreateInfo,
13481                                                  const VULKAN_HPP_NAMESPACE::AllocationCallbacks *        pAllocator,
13482                                                  VULKAN_HPP_NAMESPACE::SurfaceKHR *                       pSurface,
13483                                                  Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
13484 #  ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13485     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13486     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::SurfaceKHR>::type
13487       createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX &  createInfo,
13488                               Optional<const AllocationCallbacks> allocator
13489                                                                   VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13490                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13491 #    ifndef VULKAN_HPP_NO_SMART_HANDLE
13492     template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13493     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13494       typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR, Dispatch>>::type
13495       createScreenSurfaceQNXUnique( const ScreenSurfaceCreateInfoQNX &  createInfo,
13496                                     Optional<const AllocationCallbacks> allocator
13497                                                                         VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13498                                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
13499 #    endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13500 #  endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13501 #endif     /*VK_USE_PLATFORM_SCREEN_QNX*/
13502 
operator VkInstance() const13503     VULKAN_HPP_TYPESAFE_EXPLICIT operator VkInstance() const VULKAN_HPP_NOEXCEPT
13504     {
13505       return m_instance;
13506     }
13507 
operator bool() const13508     explicit operator bool() const VULKAN_HPP_NOEXCEPT
13509     {
13510       return m_instance != VK_NULL_HANDLE;
13511     }
13512 
operator !() const13513     bool operator!() const VULKAN_HPP_NOEXCEPT
13514     {
13515       return m_instance == VK_NULL_HANDLE;
13516     }
13517 
13518   private:
13519     VkInstance m_instance = {};
13520   };
13521   static_assert( sizeof( VULKAN_HPP_NAMESPACE::Instance ) == sizeof( VkInstance ),
13522                  "handle and wrapper have different size!" );
13523 
13524   template <>
13525   struct VULKAN_HPP_DEPRECATED( "vk::cpp_type is deprecated. Use vk::CppType instead." ) cpp_type<ObjectType::eInstance>
13526   {
13527     using type = VULKAN_HPP_NAMESPACE::Instance;
13528   };
13529 
13530   template <>
13531   struct CppType<VULKAN_HPP_NAMESPACE::ObjectType, VULKAN_HPP_NAMESPACE::ObjectType::eInstance>
13532   {
13533     using Type = VULKAN_HPP_NAMESPACE::Instance;
13534   };
13535 
13536   template <>
13537   struct CppType<VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT,
13538                  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance>
13539   {
13540     using Type = VULKAN_HPP_NAMESPACE::Instance;
13541   };
13542 
13543   template <>
13544   struct isVulkanHandleType<VULKAN_HPP_NAMESPACE::Instance>
13545   {
13546     static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
13547   };
13548 
13549   //=== VK_VERSION_1_0 ===
13550 
13551 #ifndef VULKAN_HPP_NO_SMART_HANDLE
13552   template <typename Dispatch>
13553   class UniqueHandleTraits<Instance, Dispatch>
13554   {
13555   public:
13556     using deleter = ObjectDestroy<NoParent, Dispatch>;
13557   };
13558   using UniqueInstance = UniqueHandle<Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
13559 #endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13560 
13561   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13562   VULKAN_HPP_NODISCARD Result createInstance( const VULKAN_HPP_NAMESPACE::InstanceCreateInfo *  pCreateInfo,
13563                                               const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator,
13564                                               VULKAN_HPP_NAMESPACE::Instance *                  pInstance,
13565                                               Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
13566     VULKAN_HPP_NOEXCEPT;
13567 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13568   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13569   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<VULKAN_HPP_NAMESPACE::Instance>::type
13570     createInstance( const InstanceCreateInfo &          createInfo,
13571                     Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13572                     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
13573 #  ifndef VULKAN_HPP_NO_SMART_HANDLE
13574   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13575   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
13576     typename ResultValueType<UniqueHandle<VULKAN_HPP_NAMESPACE::Instance, Dispatch>>::type
13577     createInstanceUnique( const InstanceCreateInfo &          createInfo,
13578                           Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13579                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
13580 #  endif /*VULKAN_HPP_NO_SMART_HANDLE*/
13581 #endif   /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13582 
13583   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13584   VULKAN_HPP_NODISCARD Result enumerateInstanceExtensionProperties(
13585     const char *                                pLayerName,
13586     uint32_t *                                  pPropertyCount,
13587     VULKAN_HPP_NAMESPACE::ExtensionProperties * pProperties,
13588     Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
13589 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13590   template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
13591             typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13592   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
13593     enumerateInstanceExtensionProperties( Optional<const std::string> layerName
13594                                                                       VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
13595                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
13596   template <typename ExtensionPropertiesAllocator = std::allocator<ExtensionProperties>,
13597             typename Dispatch                     = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13598             typename B                            = ExtensionPropertiesAllocator,
13599             typename std::enable_if<std::is_same<typename B::value_type, ExtensionProperties>::value, int>::type = 0>
13600   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<ExtensionProperties, ExtensionPropertiesAllocator>>::type
13601     enumerateInstanceExtensionProperties( Optional<const std::string>    layerName,
13602                                           ExtensionPropertiesAllocator & extensionPropertiesAllocator,
13603                                           Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
13604 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13605 
13606   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13607   VULKAN_HPP_NODISCARD Result
13608                        enumerateInstanceLayerProperties( uint32_t *                              pPropertyCount,
13609                                                          VULKAN_HPP_NAMESPACE::LayerProperties * pProperties,
13610                                                          Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
13611 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13612   template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
13613             typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13614   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
13615     enumerateInstanceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
13616   template <typename LayerPropertiesAllocator = std::allocator<LayerProperties>,
13617             typename Dispatch                 = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
13618             typename B                        = LayerPropertiesAllocator,
13619             typename std::enable_if<std::is_same<typename B::value_type, LayerProperties>::value, int>::type = 0>
13620   VULKAN_HPP_NODISCARD typename ResultValueType<std::vector<LayerProperties, LayerPropertiesAllocator>>::type
13621     enumerateInstanceLayerProperties( LayerPropertiesAllocator & layerPropertiesAllocator,
13622                                       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
13623 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13624 
13625   //=== VK_VERSION_1_1 ===
13626 
13627   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13628   VULKAN_HPP_NODISCARD Result enumerateInstanceVersion(
13629     uint32_t * pApiVersion, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT;
13630 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
13631   template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
13632   typename ResultValueType<uint32_t>::type
13633     enumerateInstanceVersion( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT );
13634 #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
13635 
13636 }  // namespace VULKAN_HPP_NAMESPACE
13637 #endif
13638