vkrust 0.13.2+1.4.365

// @generated by vk-gen — admitted native operations.
use super::{Device, Instance};
use crate::{self as vk, load::CallError};

/// Call `vkGetPhysicalDeviceFormatProperties` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceFormatProperties` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetPhysicalDeviceFormatProperties")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceFormatProperties`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceFormatProperties.html)"]
pub unsafe fn get_physical_device_format_properties(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	format: vk::Format,
	format_properties: &mut vk::FormatProperties,
) -> Result<(), CallError> {
	let __vk_function =
		instance
			.fp()
			.get_physical_device_format_properties
			.ok_or(CallError::MissingCommand(
				"vkGetPhysicalDeviceFormatProperties",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(physical_device, format, format_properties) };
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceFormatProperties` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceFormatProperties` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetPhysicalDeviceFormatProperties")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceFormatProperties`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceFormatProperties.html)"]
	#[inline]
	pub unsafe fn get_physical_device_format_properties(
		&self,
		physical_device: vk::PhysicalDevice,
		format: vk::Format,
		format_properties: &mut vk::FormatProperties,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_format_properties(self, physical_device, format, format_properties)
		}
	}
}

/// Call `vkGetPhysicalDeviceImageFormatProperties` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceImageFormatProperties` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetPhysicalDeviceImageFormatProperties")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceImageFormatProperties`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceImageFormatProperties.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn get_physical_device_image_format_properties(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	format: vk::Format,
	r#type: vk::ImageType,
	tiling: vk::ImageTiling,
	usage: vk::ImageUsageFlags,
	flags: vk::ImageCreateFlags,
	image_format_properties: &mut vk::ImageFormatProperties,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_image_format_properties
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceImageFormatProperties",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			physical_device,
			format,
			r#type,
			tiling,
			usage,
			flags,
			image_format_properties,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceImageFormatProperties` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceImageFormatProperties` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetPhysicalDeviceImageFormatProperties")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceImageFormatProperties`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceImageFormatProperties.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn get_physical_device_image_format_properties(
		&self,
		physical_device: vk::PhysicalDevice,
		format: vk::Format,
		r#type: vk::ImageType,
		tiling: vk::ImageTiling,
		usage: vk::ImageUsageFlags,
		flags: vk::ImageCreateFlags,
		image_format_properties: &mut vk::ImageFormatProperties,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_image_format_properties(
				self,
				physical_device,
				format,
				r#type,
				tiling,
				usage,
				flags,
				image_format_properties,
			)
		}
	}
}

/// Call `vkEnumerateDeviceLayerProperties` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkEnumerateDeviceLayerProperties` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Retries incomplete/growing results with a bounded budget; returns an error
/// if the query does not stabilize. Allocates the returned vector.
#[doc(alias = "vkEnumerateDeviceLayerProperties")]
#[doc = "\n\n[Khronos reference: `vkEnumerateDeviceLayerProperties`](https://docs.vulkan.org/refpages/latest/refpages/source/vkEnumerateDeviceLayerProperties.html)"]
pub unsafe fn enumerate_device_layer_properties(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
) -> Result<Vec<vk::LayerProperties>, CallError> {
	let __vk_function =
		instance
			.fp()
			.enumerate_device_layer_properties
			.ok_or(CallError::MissingCommand(
				"vkEnumerateDeviceLayerProperties",
			))?;
	// SAFETY: native enumeration initializes the reported plain records/bytes within capacity; the caller establishes handle validity.
	unsafe {
		crate::load::enumerate::enumerate(|count, values| __vk_function(physical_device, count, values))
	}
}

impl Instance {
	/// Call `vkEnumerateDeviceLayerProperties` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkEnumerateDeviceLayerProperties` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Retries incomplete/growing results with a bounded budget; returns an error
	/// if the query does not stabilize. Allocates the returned vector.
	#[doc(alias = "vkEnumerateDeviceLayerProperties")]
	#[doc = "\n\n[Khronos reference: `vkEnumerateDeviceLayerProperties`](https://docs.vulkan.org/refpages/latest/refpages/source/vkEnumerateDeviceLayerProperties.html)"]
	#[inline]
	pub unsafe fn enumerate_device_layer_properties(
		&self,
		physical_device: vk::PhysicalDevice,
	) -> Result<Vec<vk::LayerProperties>, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { enumerate_device_layer_properties(self, physical_device) }
	}
}

/// Call `vkDeviceWaitIdle` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDeviceWaitIdle` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkDeviceWaitIdle")]
#[doc = "\n\n[Khronos reference: `vkDeviceWaitIdle`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDeviceWaitIdle.html)"]
pub unsafe fn device_wait_idle(device: &Device) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.device_wait_idle
		.ok_or(CallError::MissingCommand("vkDeviceWaitIdle"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle()) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkDeviceWaitIdle` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDeviceWaitIdle` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkDeviceWaitIdle")]
	#[doc = "\n\n[Khronos reference: `vkDeviceWaitIdle`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDeviceWaitIdle.html)"]
	#[inline]
	pub unsafe fn device_wait_idle(&self) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { device_wait_idle(self) }
	}
}

/// Call `vkGetDeviceMemoryCommitment` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceMemoryCommitment` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetDeviceMemoryCommitment")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceMemoryCommitment`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceMemoryCommitment.html)"]
pub unsafe fn get_device_memory_commitment(
	device: &Device,
	memory: vk::DeviceMemory,
	committed_memory_in_bytes: &mut vk::DeviceSize,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_device_memory_commitment
		.ok_or(CallError::MissingCommand("vkGetDeviceMemoryCommitment"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), memory, committed_memory_in_bytes) };
	Ok(())
}

impl Device {
	/// Call `vkGetDeviceMemoryCommitment` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceMemoryCommitment` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetDeviceMemoryCommitment")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceMemoryCommitment`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceMemoryCommitment.html)"]
	#[inline]
	pub unsafe fn get_device_memory_commitment(
		&self,
		memory: vk::DeviceMemory,
		committed_memory_in_bytes: &mut vk::DeviceSize,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_device_memory_commitment(self, memory, committed_memory_in_bytes) }
	}
}

/// Call `vkGetImageMemoryRequirements` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetImageMemoryRequirements` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetImageMemoryRequirements")]
#[doc = "\n\n[Khronos reference: `vkGetImageMemoryRequirements`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageMemoryRequirements.html)"]
pub unsafe fn get_image_memory_requirements(
	device: &Device,
	image: vk::Image,
	memory_requirements: &mut vk::MemoryRequirements,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_image_memory_requirements
		.ok_or(CallError::MissingCommand("vkGetImageMemoryRequirements"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), image, memory_requirements) };
	Ok(())
}

impl Device {
	/// Call `vkGetImageMemoryRequirements` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetImageMemoryRequirements` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetImageMemoryRequirements")]
	#[doc = "\n\n[Khronos reference: `vkGetImageMemoryRequirements`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageMemoryRequirements.html)"]
	#[inline]
	pub unsafe fn get_image_memory_requirements(
		&self,
		image: vk::Image,
		memory_requirements: &mut vk::MemoryRequirements,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_image_memory_requirements(self, image, memory_requirements) }
	}
}

/// Call `vkBindImageMemory` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkBindImageMemory` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkBindImageMemory")]
#[doc = "\n\n[Khronos reference: `vkBindImageMemory`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBindImageMemory.html)"]
pub unsafe fn bind_image_memory(
	device: &Device,
	image: vk::Image,
	memory: vk::DeviceMemory,
	memory_offset: vk::DeviceSize,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.bind_image_memory
		.ok_or(CallError::MissingCommand("vkBindImageMemory"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), image, memory, memory_offset) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkBindImageMemory` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkBindImageMemory` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkBindImageMemory")]
	#[doc = "\n\n[Khronos reference: `vkBindImageMemory`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBindImageMemory.html)"]
	#[inline]
	pub unsafe fn bind_image_memory(
		&self,
		image: vk::Image,
		memory: vk::DeviceMemory,
		memory_offset: vk::DeviceSize,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { bind_image_memory(self, image, memory, memory_offset) }
	}
}

/// Call `vkGetImageSparseMemoryRequirements` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetImageSparseMemoryRequirements` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Retries incomplete/growing results with a bounded budget; returns an error
/// if the query does not stabilize. Allocates the returned vector.
#[doc(alias = "vkGetImageSparseMemoryRequirements")]
#[doc = "\n\n[Khronos reference: `vkGetImageSparseMemoryRequirements`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageSparseMemoryRequirements.html)"]
pub unsafe fn get_image_sparse_memory_requirements(
	device: &Device,
	image: vk::Image,
) -> Result<Vec<vk::SparseImageMemoryRequirements>, CallError> {
	let __vk_function =
		device
			.fp()
			.get_image_sparse_memory_requirements
			.ok_or(CallError::MissingCommand(
				"vkGetImageSparseMemoryRequirements",
			))?;
	// SAFETY: native enumeration initializes the reported plain records/bytes within capacity; the caller establishes handle validity.
	unsafe {
		crate::load::enumerate::enumerate_void(|count, values| {
			__vk_function(device.handle(), image, count, values)
		})
	}
}

impl Device {
	/// Call `vkGetImageSparseMemoryRequirements` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetImageSparseMemoryRequirements` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Retries incomplete/growing results with a bounded budget; returns an error
	/// if the query does not stabilize. Allocates the returned vector.
	#[doc(alias = "vkGetImageSparseMemoryRequirements")]
	#[doc = "\n\n[Khronos reference: `vkGetImageSparseMemoryRequirements`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageSparseMemoryRequirements.html)"]
	#[inline]
	pub unsafe fn get_image_sparse_memory_requirements(
		&self,
		image: vk::Image,
	) -> Result<Vec<vk::SparseImageMemoryRequirements>, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_image_sparse_memory_requirements(self, image) }
	}
}

/// Call `vkGetPhysicalDeviceSparseImageFormatProperties` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceSparseImageFormatProperties` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Retries incomplete/growing results with a bounded budget; returns an error
/// if the query does not stabilize. Allocates the returned vector.
#[doc(alias = "vkGetPhysicalDeviceSparseImageFormatProperties")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSparseImageFormatProperties`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSparseImageFormatProperties.html)"]
pub unsafe fn get_physical_device_sparse_image_format_properties(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	format: vk::Format,
	r#type: vk::ImageType,
	samples: vk::SampleCountFlagBits,
	usage: vk::ImageUsageFlags,
	tiling: vk::ImageTiling,
) -> Result<Vec<vk::SparseImageFormatProperties>, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_sparse_image_format_properties
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceSparseImageFormatProperties",
		))?;
	// SAFETY: native enumeration initializes the reported plain records/bytes within capacity; the caller establishes handle validity.
	unsafe {
		crate::load::enumerate::enumerate_void(|count, values| {
			__vk_function(
				physical_device,
				format,
				r#type,
				samples,
				usage,
				tiling,
				count,
				values,
			)
		})
	}
}

impl Instance {
	/// Call `vkGetPhysicalDeviceSparseImageFormatProperties` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceSparseImageFormatProperties` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Retries incomplete/growing results with a bounded budget; returns an error
	/// if the query does not stabilize. Allocates the returned vector.
	#[doc(alias = "vkGetPhysicalDeviceSparseImageFormatProperties")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSparseImageFormatProperties`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSparseImageFormatProperties.html)"]
	#[inline]
	pub unsafe fn get_physical_device_sparse_image_format_properties(
		&self,
		physical_device: vk::PhysicalDevice,
		format: vk::Format,
		r#type: vk::ImageType,
		samples: vk::SampleCountFlagBits,
		usage: vk::ImageUsageFlags,
		tiling: vk::ImageTiling,
	) -> Result<Vec<vk::SparseImageFormatProperties>, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_sparse_image_format_properties(
				self,
				physical_device,
				format,
				r#type,
				samples,
				usage,
				tiling,
			)
		}
	}
}

/// Call `vkQueueBindSparse` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkQueueBindSparse` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkQueueBindSparse")]
#[doc = "\n\n[Khronos reference: `vkQueueBindSparse`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueueBindSparse.html)"]
pub unsafe fn queue_bind_sparse(
	device: &Device,
	queue: vk::Queue,
	bind_info: &[vk::BindSparseInfo<'_>],
	fence: vk::Fence,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.queue_bind_sparse
		.ok_or(CallError::MissingCommand("vkQueueBindSparse"))?;
	let bind_info_count =
		u32::try_from(bind_info.len()).map_err(|_| CallError::CountOverflow(bind_info.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(queue, bind_info_count, bind_info.as_ptr(), fence) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkQueueBindSparse` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkQueueBindSparse` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkQueueBindSparse")]
	#[doc = "\n\n[Khronos reference: `vkQueueBindSparse`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueueBindSparse.html)"]
	#[inline]
	pub unsafe fn queue_bind_sparse(
		&self,
		queue: vk::Queue,
		bind_info: &[vk::BindSparseInfo<'_>],
		fence: vk::Fence,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { queue_bind_sparse(self, queue, bind_info, fence) }
	}
}

/// Call `vkGetFenceStatus` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetFenceStatus` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetFenceStatus")]
#[doc = "\n\n[Khronos reference: `vkGetFenceStatus`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetFenceStatus.html)"]
pub unsafe fn get_fence_status(device: &Device, fence: vk::Fence) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_fence_status
		.ok_or(CallError::MissingCommand("vkGetFenceStatus"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), fence) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetFenceStatus` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetFenceStatus` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetFenceStatus")]
	#[doc = "\n\n[Khronos reference: `vkGetFenceStatus`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetFenceStatus.html)"]
	#[inline]
	pub unsafe fn get_fence_status(&self, fence: vk::Fence) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_fence_status(self, fence) }
	}
}

/// Call `vkCreateSemaphore` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateSemaphore` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCreateSemaphore")]
#[doc = "\n\n[Khronos reference: `vkCreateSemaphore`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateSemaphore.html)"]
pub unsafe fn create_semaphore(
	device: &Device,
	create_info: &vk::SemaphoreCreateInfo<'_>,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<vk::Semaphore, CallError> {
	let __vk_function = device
		.fp()
		.create_semaphore
		.ok_or(CallError::MissingCommand("vkCreateSemaphore"))?;
	let mut output = vk::Semaphore::NULL;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info,
			allocator.map_or(std::ptr::null(), |value| value),
			&mut output,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(output)
}

impl Device {
	/// Call `vkCreateSemaphore` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateSemaphore` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCreateSemaphore")]
	#[doc = "\n\n[Khronos reference: `vkCreateSemaphore`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateSemaphore.html)"]
	#[inline]
	pub unsafe fn create_semaphore(
		&self,
		create_info: &vk::SemaphoreCreateInfo<'_>,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<vk::Semaphore, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_semaphore(self, create_info, allocator) }
	}
}

/// Call `vkDestroySemaphore` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroySemaphore` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkDestroySemaphore")]
#[doc = "\n\n[Khronos reference: `vkDestroySemaphore`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroySemaphore.html)"]
pub unsafe fn destroy_semaphore(
	device: &Device,
	semaphore: vk::Semaphore,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_semaphore
		.ok_or(CallError::MissingCommand("vkDestroySemaphore"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			semaphore,
			allocator.map_or(std::ptr::null(), |value| value),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkDestroySemaphore` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroySemaphore` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkDestroySemaphore")]
	#[doc = "\n\n[Khronos reference: `vkDestroySemaphore`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroySemaphore.html)"]
	#[inline]
	pub unsafe fn destroy_semaphore(
		&self,
		semaphore: vk::Semaphore,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_semaphore(self, semaphore, allocator) }
	}
}

/// Call `vkCreateEvent` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateEvent` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCreateEvent")]
#[doc = "\n\n[Khronos reference: `vkCreateEvent`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateEvent.html)"]
pub unsafe fn create_event(
	device: &Device,
	create_info: &vk::EventCreateInfo<'_>,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<vk::Event, CallError> {
	let __vk_function = device
		.fp()
		.create_event
		.ok_or(CallError::MissingCommand("vkCreateEvent"))?;
	let mut output = vk::Event::NULL;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info,
			allocator.map_or(std::ptr::null(), |value| value),
			&mut output,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(output)
}

impl Device {
	/// Call `vkCreateEvent` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateEvent` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCreateEvent")]
	#[doc = "\n\n[Khronos reference: `vkCreateEvent`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateEvent.html)"]
	#[inline]
	pub unsafe fn create_event(
		&self,
		create_info: &vk::EventCreateInfo<'_>,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<vk::Event, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_event(self, create_info, allocator) }
	}
}

/// Call `vkDestroyEvent` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyEvent` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkDestroyEvent")]
#[doc = "\n\n[Khronos reference: `vkDestroyEvent`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyEvent.html)"]
pub unsafe fn destroy_event(
	device: &Device,
	event: vk::Event,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_event
		.ok_or(CallError::MissingCommand("vkDestroyEvent"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			event,
			allocator.map_or(std::ptr::null(), |value| value),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkDestroyEvent` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyEvent` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkDestroyEvent")]
	#[doc = "\n\n[Khronos reference: `vkDestroyEvent`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyEvent.html)"]
	#[inline]
	pub unsafe fn destroy_event(
		&self,
		event: vk::Event,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_event(self, event, allocator) }
	}
}

/// Call `vkGetEventStatus` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetEventStatus` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetEventStatus")]
#[doc = "\n\n[Khronos reference: `vkGetEventStatus`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetEventStatus.html)"]
pub unsafe fn get_event_status(device: &Device, event: vk::Event) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_event_status
		.ok_or(CallError::MissingCommand("vkGetEventStatus"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), event) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetEventStatus` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetEventStatus` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetEventStatus")]
	#[doc = "\n\n[Khronos reference: `vkGetEventStatus`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetEventStatus.html)"]
	#[inline]
	pub unsafe fn get_event_status(&self, event: vk::Event) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_event_status(self, event) }
	}
}

/// Call `vkSetEvent` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkSetEvent` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkSetEvent")]
#[doc = "\n\n[Khronos reference: `vkSetEvent`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetEvent.html)"]
pub unsafe fn set_event(device: &Device, event: vk::Event) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.set_event
		.ok_or(CallError::MissingCommand("vkSetEvent"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), event) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkSetEvent` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkSetEvent` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkSetEvent")]
	#[doc = "\n\n[Khronos reference: `vkSetEvent`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetEvent.html)"]
	#[inline]
	pub unsafe fn set_event(&self, event: vk::Event) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { set_event(self, event) }
	}
}

/// Call `vkResetEvent` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkResetEvent` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkResetEvent")]
#[doc = "\n\n[Khronos reference: `vkResetEvent`](https://docs.vulkan.org/refpages/latest/refpages/source/vkResetEvent.html)"]
pub unsafe fn reset_event(device: &Device, event: vk::Event) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.reset_event
		.ok_or(CallError::MissingCommand("vkResetEvent"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), event) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkResetEvent` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkResetEvent` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkResetEvent")]
	#[doc = "\n\n[Khronos reference: `vkResetEvent`](https://docs.vulkan.org/refpages/latest/refpages/source/vkResetEvent.html)"]
	#[inline]
	pub unsafe fn reset_event(&self, event: vk::Event) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { reset_event(self, event) }
	}
}

/// Call `vkCreateQueryPool` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateQueryPool` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCreateQueryPool")]
#[doc = "\n\n[Khronos reference: `vkCreateQueryPool`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateQueryPool.html)"]
pub unsafe fn create_query_pool(
	device: &Device,
	create_info: &vk::QueryPoolCreateInfo<'_>,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<vk::QueryPool, CallError> {
	let __vk_function = device
		.fp()
		.create_query_pool
		.ok_or(CallError::MissingCommand("vkCreateQueryPool"))?;
	let mut output = vk::QueryPool::NULL;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info,
			allocator.map_or(std::ptr::null(), |value| value),
			&mut output,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(output)
}

impl Device {
	/// Call `vkCreateQueryPool` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateQueryPool` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCreateQueryPool")]
	#[doc = "\n\n[Khronos reference: `vkCreateQueryPool`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateQueryPool.html)"]
	#[inline]
	pub unsafe fn create_query_pool(
		&self,
		create_info: &vk::QueryPoolCreateInfo<'_>,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<vk::QueryPool, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_query_pool(self, create_info, allocator) }
	}
}

/// Call `vkDestroyQueryPool` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyQueryPool` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkDestroyQueryPool")]
#[doc = "\n\n[Khronos reference: `vkDestroyQueryPool`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyQueryPool.html)"]
pub unsafe fn destroy_query_pool(
	device: &Device,
	query_pool: vk::QueryPool,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_query_pool
		.ok_or(CallError::MissingCommand("vkDestroyQueryPool"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			query_pool,
			allocator.map_or(std::ptr::null(), |value| value),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkDestroyQueryPool` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyQueryPool` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkDestroyQueryPool")]
	#[doc = "\n\n[Khronos reference: `vkDestroyQueryPool`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyQueryPool.html)"]
	#[inline]
	pub unsafe fn destroy_query_pool(
		&self,
		query_pool: vk::QueryPool,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_query_pool(self, query_pool, allocator) }
	}
}

/// Call `vkGetQueryPoolResults` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetQueryPoolResults` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Byte slices determine native byte counts. The caller must also satisfy the
/// command's data alignment, format, size-multiple and stride requirements;
/// a byte slice alone does not establish those properties.
#[doc(alias = "vkGetQueryPoolResults")]
#[doc = "\n\n[Khronos reference: `vkGetQueryPoolResults`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetQueryPoolResults.html)"]
pub unsafe fn get_query_pool_results(
	device: &Device,
	query_pool: vk::QueryPool,
	first_query: u32,
	query_count: u32,
	data: &mut [u8],
	stride: vk::DeviceSize,
	flags: vk::QueryResultFlags,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_query_pool_results
		.ok_or(CallError::MissingCommand("vkGetQueryPoolResults"))?;
	let data_size = data.len();
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			query_pool,
			first_query,
			query_count,
			data_size,
			data.as_mut_ptr().cast(),
			stride,
			flags,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetQueryPoolResults` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetQueryPoolResults` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Byte slices determine native byte counts. The caller must also satisfy the
	/// command's data alignment, format, size-multiple and stride requirements;
	/// a byte slice alone does not establish those properties.
	#[doc(alias = "vkGetQueryPoolResults")]
	#[doc = "\n\n[Khronos reference: `vkGetQueryPoolResults`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetQueryPoolResults.html)"]
	#[inline]
	pub unsafe fn get_query_pool_results(
		&self,
		query_pool: vk::QueryPool,
		first_query: u32,
		query_count: u32,
		data: &mut [u8],
		stride: vk::DeviceSize,
		flags: vk::QueryResultFlags,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_query_pool_results(
				self,
				query_pool,
				first_query,
				query_count,
				data,
				stride,
				flags,
			)
		}
	}
}

/// Call `vkResetQueryPool` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkResetQueryPool` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkResetQueryPool")]
#[doc = "\n\n[Khronos reference: `vkResetQueryPool`](https://docs.vulkan.org/refpages/latest/refpages/source/vkResetQueryPool.html)"]
pub unsafe fn reset_query_pool(
	device: &Device,
	query_pool: vk::QueryPool,
	first_query: u32,
	query_count: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.reset_query_pool
		.ok_or(CallError::MissingCommand("vkResetQueryPool"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), query_pool, first_query, query_count) };
	Ok(())
}

impl Device {
	/// Call `vkResetQueryPool` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkResetQueryPool` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkResetQueryPool")]
	#[doc = "\n\n[Khronos reference: `vkResetQueryPool`](https://docs.vulkan.org/refpages/latest/refpages/source/vkResetQueryPool.html)"]
	#[inline]
	pub unsafe fn reset_query_pool(
		&self,
		query_pool: vk::QueryPool,
		first_query: u32,
		query_count: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { reset_query_pool(self, query_pool, first_query, query_count) }
	}
}

/// Call `vkResetQueryPoolEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkResetQueryPoolEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkResetQueryPoolEXT")]
#[doc = "\n\n[Khronos reference: `vkResetQueryPoolEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkResetQueryPoolEXT.html)"]
pub unsafe fn reset_query_pool_ext(
	device: &Device,
	query_pool: vk::QueryPool,
	first_query: u32,
	query_count: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.reset_query_pool_ext
		.ok_or(CallError::MissingCommand("vkResetQueryPoolEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), query_pool, first_query, query_count) };
	Ok(())
}

impl Device {
	/// Call `vkResetQueryPoolEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkResetQueryPoolEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkResetQueryPoolEXT")]
	#[doc = "\n\n[Khronos reference: `vkResetQueryPoolEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkResetQueryPoolEXT.html)"]
	#[inline]
	pub unsafe fn reset_query_pool_ext(
		&self,
		query_pool: vk::QueryPool,
		first_query: u32,
		query_count: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { reset_query_pool_ext(self, query_pool, first_query, query_count) }
	}
}

/// Call `vkCreateBufferView` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateBufferView` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCreateBufferView")]
#[doc = "\n\n[Khronos reference: `vkCreateBufferView`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateBufferView.html)"]
pub unsafe fn create_buffer_view(
	device: &Device,
	create_info: &vk::BufferViewCreateInfo<'_>,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<vk::BufferView, CallError> {
	let __vk_function = device
		.fp()
		.create_buffer_view
		.ok_or(CallError::MissingCommand("vkCreateBufferView"))?;
	let mut output = vk::BufferView::NULL;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info,
			allocator.map_or(std::ptr::null(), |value| value),
			&mut output,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(output)
}

impl Device {
	/// Call `vkCreateBufferView` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateBufferView` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCreateBufferView")]
	#[doc = "\n\n[Khronos reference: `vkCreateBufferView`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateBufferView.html)"]
	#[inline]
	pub unsafe fn create_buffer_view(
		&self,
		create_info: &vk::BufferViewCreateInfo<'_>,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<vk::BufferView, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_buffer_view(self, create_info, allocator) }
	}
}

/// Call `vkDestroyBufferView` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyBufferView` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkDestroyBufferView")]
#[doc = "\n\n[Khronos reference: `vkDestroyBufferView`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyBufferView.html)"]
pub unsafe fn destroy_buffer_view(
	device: &Device,
	buffer_view: vk::BufferView,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_buffer_view
		.ok_or(CallError::MissingCommand("vkDestroyBufferView"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			buffer_view,
			allocator.map_or(std::ptr::null(), |value| value),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkDestroyBufferView` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyBufferView` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkDestroyBufferView")]
	#[doc = "\n\n[Khronos reference: `vkDestroyBufferView`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyBufferView.html)"]
	#[inline]
	pub unsafe fn destroy_buffer_view(
		&self,
		buffer_view: vk::BufferView,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_buffer_view(self, buffer_view, allocator) }
	}
}

/// Call `vkCreateImage` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateImage` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCreateImage")]
#[doc = "\n\n[Khronos reference: `vkCreateImage`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateImage.html)"]
pub unsafe fn create_image(
	device: &Device,
	create_info: &vk::ImageCreateInfo<'_>,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<vk::Image, CallError> {
	let __vk_function = device
		.fp()
		.create_image
		.ok_or(CallError::MissingCommand("vkCreateImage"))?;
	let mut output = vk::Image::NULL;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info,
			allocator.map_or(std::ptr::null(), |value| value),
			&mut output,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(output)
}

impl Device {
	/// Call `vkCreateImage` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateImage` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCreateImage")]
	#[doc = "\n\n[Khronos reference: `vkCreateImage`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateImage.html)"]
	#[inline]
	pub unsafe fn create_image(
		&self,
		create_info: &vk::ImageCreateInfo<'_>,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<vk::Image, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_image(self, create_info, allocator) }
	}
}

/// Call `vkDestroyImage` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyImage` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkDestroyImage")]
#[doc = "\n\n[Khronos reference: `vkDestroyImage`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyImage.html)"]
pub unsafe fn destroy_image(
	device: &Device,
	image: vk::Image,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_image
		.ok_or(CallError::MissingCommand("vkDestroyImage"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			image,
			allocator.map_or(std::ptr::null(), |value| value),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkDestroyImage` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyImage` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkDestroyImage")]
	#[doc = "\n\n[Khronos reference: `vkDestroyImage`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyImage.html)"]
	#[inline]
	pub unsafe fn destroy_image(
		&self,
		image: vk::Image,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_image(self, image, allocator) }
	}
}

/// Call `vkGetImageSubresourceLayout` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetImageSubresourceLayout` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetImageSubresourceLayout")]
#[doc = "\n\n[Khronos reference: `vkGetImageSubresourceLayout`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageSubresourceLayout.html)"]
pub unsafe fn get_image_subresource_layout(
	device: &Device,
	image: vk::Image,
	subresource: &vk::ImageSubresource,
	layout: &mut vk::SubresourceLayout,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_image_subresource_layout
		.ok_or(CallError::MissingCommand("vkGetImageSubresourceLayout"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), image, subresource, layout) };
	Ok(())
}

impl Device {
	/// Call `vkGetImageSubresourceLayout` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetImageSubresourceLayout` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetImageSubresourceLayout")]
	#[doc = "\n\n[Khronos reference: `vkGetImageSubresourceLayout`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageSubresourceLayout.html)"]
	#[inline]
	pub unsafe fn get_image_subresource_layout(
		&self,
		image: vk::Image,
		subresource: &vk::ImageSubresource,
		layout: &mut vk::SubresourceLayout,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_image_subresource_layout(self, image, subresource, layout) }
	}
}

/// Call `vkCreateImageView` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateImageView` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCreateImageView")]
#[doc = "\n\n[Khronos reference: `vkCreateImageView`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateImageView.html)"]
pub unsafe fn create_image_view(
	device: &Device,
	create_info: &vk::ImageViewCreateInfo<'_>,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<vk::ImageView, CallError> {
	let __vk_function = device
		.fp()
		.create_image_view
		.ok_or(CallError::MissingCommand("vkCreateImageView"))?;
	let mut output = vk::ImageView::NULL;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info,
			allocator.map_or(std::ptr::null(), |value| value),
			&mut output,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(output)
}

impl Device {
	/// Call `vkCreateImageView` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateImageView` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCreateImageView")]
	#[doc = "\n\n[Khronos reference: `vkCreateImageView`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateImageView.html)"]
	#[inline]
	pub unsafe fn create_image_view(
		&self,
		create_info: &vk::ImageViewCreateInfo<'_>,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<vk::ImageView, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_image_view(self, create_info, allocator) }
	}
}

/// Call `vkDestroyImageView` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyImageView` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkDestroyImageView")]
#[doc = "\n\n[Khronos reference: `vkDestroyImageView`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyImageView.html)"]
pub unsafe fn destroy_image_view(
	device: &Device,
	image_view: vk::ImageView,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_image_view
		.ok_or(CallError::MissingCommand("vkDestroyImageView"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			image_view,
			allocator.map_or(std::ptr::null(), |value| value),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkDestroyImageView` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyImageView` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkDestroyImageView")]
	#[doc = "\n\n[Khronos reference: `vkDestroyImageView`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyImageView.html)"]
	#[inline]
	pub unsafe fn destroy_image_view(
		&self,
		image_view: vk::ImageView,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_image_view(self, image_view, allocator) }
	}
}

/// Call `vkCreateShaderModule` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateShaderModule` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCreateShaderModule")]
#[doc = "\n\n[Khronos reference: `vkCreateShaderModule`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateShaderModule.html)"]
pub unsafe fn create_shader_module(
	device: &Device,
	create_info: &vk::ShaderModuleCreateInfo<'_>,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<vk::ShaderModule, CallError> {
	let __vk_function = device
		.fp()
		.create_shader_module
		.ok_or(CallError::MissingCommand("vkCreateShaderModule"))?;
	let mut output = vk::ShaderModule::NULL;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info,
			allocator.map_or(std::ptr::null(), |value| value),
			&mut output,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(output)
}

impl Device {
	/// Call `vkCreateShaderModule` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateShaderModule` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCreateShaderModule")]
	#[doc = "\n\n[Khronos reference: `vkCreateShaderModule`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateShaderModule.html)"]
	#[inline]
	pub unsafe fn create_shader_module(
		&self,
		create_info: &vk::ShaderModuleCreateInfo<'_>,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<vk::ShaderModule, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_shader_module(self, create_info, allocator) }
	}
}

/// Call `vkDestroyShaderModule` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyShaderModule` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkDestroyShaderModule")]
#[doc = "\n\n[Khronos reference: `vkDestroyShaderModule`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyShaderModule.html)"]
pub unsafe fn destroy_shader_module(
	device: &Device,
	shader_module: vk::ShaderModule,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_shader_module
		.ok_or(CallError::MissingCommand("vkDestroyShaderModule"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			shader_module,
			allocator.map_or(std::ptr::null(), |value| value),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkDestroyShaderModule` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyShaderModule` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkDestroyShaderModule")]
	#[doc = "\n\n[Khronos reference: `vkDestroyShaderModule`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyShaderModule.html)"]
	#[inline]
	pub unsafe fn destroy_shader_module(
		&self,
		shader_module: vk::ShaderModule,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_shader_module(self, shader_module, allocator) }
	}
}

/// Call `vkCreatePipelineCache` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreatePipelineCache` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCreatePipelineCache")]
#[doc = "\n\n[Khronos reference: `vkCreatePipelineCache`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreatePipelineCache.html)"]
pub unsafe fn create_pipeline_cache(
	device: &Device,
	create_info: &vk::PipelineCacheCreateInfo<'_>,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<vk::PipelineCache, CallError> {
	let __vk_function = device
		.fp()
		.create_pipeline_cache
		.ok_or(CallError::MissingCommand("vkCreatePipelineCache"))?;
	let mut output = vk::PipelineCache::NULL;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info,
			allocator.map_or(std::ptr::null(), |value| value),
			&mut output,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(output)
}

impl Device {
	/// Call `vkCreatePipelineCache` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreatePipelineCache` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCreatePipelineCache")]
	#[doc = "\n\n[Khronos reference: `vkCreatePipelineCache`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreatePipelineCache.html)"]
	#[inline]
	pub unsafe fn create_pipeline_cache(
		&self,
		create_info: &vk::PipelineCacheCreateInfo<'_>,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<vk::PipelineCache, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_pipeline_cache(self, create_info, allocator) }
	}
}

/// Call `vkDestroyPipelineCache` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyPipelineCache` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkDestroyPipelineCache")]
#[doc = "\n\n[Khronos reference: `vkDestroyPipelineCache`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyPipelineCache.html)"]
pub unsafe fn destroy_pipeline_cache(
	device: &Device,
	pipeline_cache: vk::PipelineCache,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_pipeline_cache
		.ok_or(CallError::MissingCommand("vkDestroyPipelineCache"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			pipeline_cache,
			allocator.map_or(std::ptr::null(), |value| value),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkDestroyPipelineCache` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyPipelineCache` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkDestroyPipelineCache")]
	#[doc = "\n\n[Khronos reference: `vkDestroyPipelineCache`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyPipelineCache.html)"]
	#[inline]
	pub unsafe fn destroy_pipeline_cache(
		&self,
		pipeline_cache: vk::PipelineCache,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_pipeline_cache(self, pipeline_cache, allocator) }
	}
}

/// Call `vkGetPipelineCacheData` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPipelineCacheData` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Retries incomplete/growing results with a bounded budget; returns an error
/// if the query does not stabilize. Allocates the returned vector.
#[doc(alias = "vkGetPipelineCacheData")]
#[doc = "\n\n[Khronos reference: `vkGetPipelineCacheData`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPipelineCacheData.html)"]
pub unsafe fn get_pipeline_cache_data(
	device: &Device,
	pipeline_cache: vk::PipelineCache,
) -> Result<Vec<u8>, CallError> {
	let __vk_function = device
		.fp()
		.get_pipeline_cache_data
		.ok_or(CallError::MissingCommand("vkGetPipelineCacheData"))?;
	// SAFETY: native enumeration initializes the reported plain records/bytes within capacity; the caller establishes handle validity.
	unsafe {
		crate::load::enumerate::enumerate_bytes(|count, values| {
			__vk_function(device.handle(), pipeline_cache, count, values.cast())
		})
	}
}

impl Device {
	/// Call `vkGetPipelineCacheData` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPipelineCacheData` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Retries incomplete/growing results with a bounded budget; returns an error
	/// if the query does not stabilize. Allocates the returned vector.
	#[doc(alias = "vkGetPipelineCacheData")]
	#[doc = "\n\n[Khronos reference: `vkGetPipelineCacheData`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPipelineCacheData.html)"]
	#[inline]
	pub unsafe fn get_pipeline_cache_data(
		&self,
		pipeline_cache: vk::PipelineCache,
	) -> Result<Vec<u8>, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_pipeline_cache_data(self, pipeline_cache) }
	}
}

/// Call `vkMergePipelineCaches` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkMergePipelineCaches` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkMergePipelineCaches")]
#[doc = "\n\n[Khronos reference: `vkMergePipelineCaches`](https://docs.vulkan.org/refpages/latest/refpages/source/vkMergePipelineCaches.html)"]
pub unsafe fn merge_pipeline_caches(
	device: &Device,
	dst_cache: vk::PipelineCache,
	src_caches: &[vk::PipelineCache],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.merge_pipeline_caches
		.ok_or(CallError::MissingCommand("vkMergePipelineCaches"))?;
	let src_cache_count =
		u32::try_from(src_caches.len()).map_err(|_| CallError::CountOverflow(src_caches.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			dst_cache,
			src_cache_count,
			src_caches.as_ptr(),
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkMergePipelineCaches` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkMergePipelineCaches` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkMergePipelineCaches")]
	#[doc = "\n\n[Khronos reference: `vkMergePipelineCaches`](https://docs.vulkan.org/refpages/latest/refpages/source/vkMergePipelineCaches.html)"]
	#[inline]
	pub unsafe fn merge_pipeline_caches(
		&self,
		dst_cache: vk::PipelineCache,
		src_caches: &[vk::PipelineCache],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { merge_pipeline_caches(self, dst_cache, src_caches) }
	}
}

/// Call `vkCreatePipelineBinariesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreatePipelineBinariesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreatePipelineBinariesKHR")]
#[doc = "\n\n[Khronos reference: `vkCreatePipelineBinariesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreatePipelineBinariesKHR.html)"]
pub unsafe fn create_pipeline_binaries_khr(
	device: &Device,
	p_create_info: *const vk::PipelineBinaryCreateInfoKHR<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_binaries: *mut vk::PipelineBinaryHandlesInfoKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_pipeline_binaries_khr
		.ok_or(CallError::MissingCommand("vkCreatePipelineBinariesKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_create_info, p_allocator, p_binaries) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreatePipelineBinariesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreatePipelineBinariesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreatePipelineBinariesKHR")]
	#[doc = "\n\n[Khronos reference: `vkCreatePipelineBinariesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreatePipelineBinariesKHR.html)"]
	#[inline]
	pub unsafe fn create_pipeline_binaries_khr(
		&self,
		p_create_info: *const vk::PipelineBinaryCreateInfoKHR<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_binaries: *mut vk::PipelineBinaryHandlesInfoKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_pipeline_binaries_khr(self, p_create_info, p_allocator, p_binaries) }
	}
}

/// Call `vkDestroyPipelineBinaryKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyPipelineBinaryKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyPipelineBinaryKHR")]
#[doc = "\n\n[Khronos reference: `vkDestroyPipelineBinaryKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyPipelineBinaryKHR.html)"]
pub unsafe fn destroy_pipeline_binary_khr(
	device: &Device,
	pipeline_binary: vk::PipelineBinaryKHR,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_pipeline_binary_khr
		.ok_or(CallError::MissingCommand("vkDestroyPipelineBinaryKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), pipeline_binary, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyPipelineBinaryKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyPipelineBinaryKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyPipelineBinaryKHR")]
	#[doc = "\n\n[Khronos reference: `vkDestroyPipelineBinaryKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyPipelineBinaryKHR.html)"]
	#[inline]
	pub unsafe fn destroy_pipeline_binary_khr(
		&self,
		pipeline_binary: vk::PipelineBinaryKHR,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_pipeline_binary_khr(self, pipeline_binary, p_allocator) }
	}
}

/// Call `vkGetPipelineKeyKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPipelineKeyKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPipelineKeyKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPipelineKeyKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPipelineKeyKHR.html)"]
pub unsafe fn get_pipeline_key_khr(
	device: &Device,
	p_pipeline_create_info: *const vk::PipelineCreateInfoKHR<'_>,
	p_pipeline_key: *mut vk::PipelineBinaryKeyKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_pipeline_key_khr
		.ok_or(CallError::MissingCommand("vkGetPipelineKeyKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_pipeline_create_info, p_pipeline_key) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetPipelineKeyKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPipelineKeyKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPipelineKeyKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPipelineKeyKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPipelineKeyKHR.html)"]
	#[inline]
	pub unsafe fn get_pipeline_key_khr(
		&self,
		p_pipeline_create_info: *const vk::PipelineCreateInfoKHR<'_>,
		p_pipeline_key: *mut vk::PipelineBinaryKeyKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_pipeline_key_khr(self, p_pipeline_create_info, p_pipeline_key) }
	}
}

/// Call `vkGetPipelineBinaryDataKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPipelineBinaryDataKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPipelineBinaryDataKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPipelineBinaryDataKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPipelineBinaryDataKHR.html)"]
pub unsafe fn get_pipeline_binary_data_khr(
	device: &Device,
	p_info: *const vk::PipelineBinaryDataInfoKHR<'_>,
	p_pipeline_binary_key: *mut vk::PipelineBinaryKeyKHR<'_>,
	p_pipeline_binary_data_size: *mut usize,
	p_pipeline_binary_data: *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_pipeline_binary_data_khr
		.ok_or(CallError::MissingCommand("vkGetPipelineBinaryDataKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_info,
			p_pipeline_binary_key,
			p_pipeline_binary_data_size,
			p_pipeline_binary_data,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetPipelineBinaryDataKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPipelineBinaryDataKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPipelineBinaryDataKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPipelineBinaryDataKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPipelineBinaryDataKHR.html)"]
	#[inline]
	pub unsafe fn get_pipeline_binary_data_khr(
		&self,
		p_info: *const vk::PipelineBinaryDataInfoKHR<'_>,
		p_pipeline_binary_key: *mut vk::PipelineBinaryKeyKHR<'_>,
		p_pipeline_binary_data_size: *mut usize,
		p_pipeline_binary_data: *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_pipeline_binary_data_khr(
				self,
				p_info,
				p_pipeline_binary_key,
				p_pipeline_binary_data_size,
				p_pipeline_binary_data,
			)
		}
	}
}

/// Call `vkReleaseCapturedPipelineDataKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkReleaseCapturedPipelineDataKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkReleaseCapturedPipelineDataKHR")]
#[doc = "\n\n[Khronos reference: `vkReleaseCapturedPipelineDataKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkReleaseCapturedPipelineDataKHR.html)"]
pub unsafe fn release_captured_pipeline_data_khr(
	device: &Device,
	p_info: *const vk::ReleaseCapturedPipelineDataInfoKHR<'_>,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.release_captured_pipeline_data_khr
			.ok_or(CallError::MissingCommand(
				"vkReleaseCapturedPipelineDataKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_info, p_allocator) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkReleaseCapturedPipelineDataKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkReleaseCapturedPipelineDataKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkReleaseCapturedPipelineDataKHR")]
	#[doc = "\n\n[Khronos reference: `vkReleaseCapturedPipelineDataKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkReleaseCapturedPipelineDataKHR.html)"]
	#[inline]
	pub unsafe fn release_captured_pipeline_data_khr(
		&self,
		p_info: *const vk::ReleaseCapturedPipelineDataInfoKHR<'_>,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { release_captured_pipeline_data_khr(self, p_info, p_allocator) }
	}
}

/// Call `vkCreateGraphicsPipelines` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateGraphicsPipelines` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Returns non-error native status codes unchanged, including compile-required.
/// On native failure, output slots can contain successfully created pipelines;
/// the caller must inspect and destroy every non-null handle. Slots are not reset
/// before the call: their previous contents must not own live resources.
#[doc(alias = "vkCreateGraphicsPipelines")]
#[doc = "\n\n[Khronos reference: `vkCreateGraphicsPipelines`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateGraphicsPipelines.html)"]
pub unsafe fn create_graphics_pipelines(
	device: &Device,
	pipeline_cache: vk::PipelineCache,
	create_infos: &[vk::GraphicsPipelineCreateInfo<'_>],
	allocator: Option<&vk::AllocationCallbacks>,
	pipelines: &mut [vk::Pipeline],
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_graphics_pipelines
		.ok_or(CallError::MissingCommand("vkCreateGraphicsPipelines"))?;
	let create_info_count =
		u32::try_from(create_infos.len()).map_err(|_| CallError::CountOverflow(create_infos.len()))?;
	if pipelines.len() != create_infos.len() {
		return Err(CallError::SliceLengthMismatch {
			parameter: "pipelines",
			expected: create_infos.len(),
			actual: pipelines.len(),
		});
	}
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			pipeline_cache,
			create_info_count,
			create_infos.as_ptr(),
			allocator.map_or(std::ptr::null(), |value| value),
			pipelines.as_mut_ptr(),
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateGraphicsPipelines` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateGraphicsPipelines` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Returns non-error native status codes unchanged, including compile-required.
	/// On native failure, output slots can contain successfully created pipelines;
	/// the caller must inspect and destroy every non-null handle. Slots are not reset
	/// before the call: their previous contents must not own live resources.
	#[doc(alias = "vkCreateGraphicsPipelines")]
	#[doc = "\n\n[Khronos reference: `vkCreateGraphicsPipelines`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateGraphicsPipelines.html)"]
	#[inline]
	pub unsafe fn create_graphics_pipelines(
		&self,
		pipeline_cache: vk::PipelineCache,
		create_infos: &[vk::GraphicsPipelineCreateInfo<'_>],
		allocator: Option<&vk::AllocationCallbacks>,
		pipelines: &mut [vk::Pipeline],
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_graphics_pipelines(self, pipeline_cache, create_infos, allocator, pipelines) }
	}
}

/// Call `vkCreateComputePipelines` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateComputePipelines` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Returns non-error native status codes unchanged, including compile-required.
/// On native failure, output slots can contain successfully created pipelines;
/// the caller must inspect and destroy every non-null handle. Slots are not reset
/// before the call: their previous contents must not own live resources.
#[doc(alias = "vkCreateComputePipelines")]
#[doc = "\n\n[Khronos reference: `vkCreateComputePipelines`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateComputePipelines.html)"]
pub unsafe fn create_compute_pipelines(
	device: &Device,
	pipeline_cache: vk::PipelineCache,
	create_infos: &[vk::ComputePipelineCreateInfo<'_>],
	allocator: Option<&vk::AllocationCallbacks>,
	pipelines: &mut [vk::Pipeline],
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_compute_pipelines
		.ok_or(CallError::MissingCommand("vkCreateComputePipelines"))?;
	let create_info_count =
		u32::try_from(create_infos.len()).map_err(|_| CallError::CountOverflow(create_infos.len()))?;
	if pipelines.len() != create_infos.len() {
		return Err(CallError::SliceLengthMismatch {
			parameter: "pipelines",
			expected: create_infos.len(),
			actual: pipelines.len(),
		});
	}
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			pipeline_cache,
			create_info_count,
			create_infos.as_ptr(),
			allocator.map_or(std::ptr::null(), |value| value),
			pipelines.as_mut_ptr(),
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateComputePipelines` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateComputePipelines` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Returns non-error native status codes unchanged, including compile-required.
	/// On native failure, output slots can contain successfully created pipelines;
	/// the caller must inspect and destroy every non-null handle. Slots are not reset
	/// before the call: their previous contents must not own live resources.
	#[doc(alias = "vkCreateComputePipelines")]
	#[doc = "\n\n[Khronos reference: `vkCreateComputePipelines`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateComputePipelines.html)"]
	#[inline]
	pub unsafe fn create_compute_pipelines(
		&self,
		pipeline_cache: vk::PipelineCache,
		create_infos: &[vk::ComputePipelineCreateInfo<'_>],
		allocator: Option<&vk::AllocationCallbacks>,
		pipelines: &mut [vk::Pipeline],
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_compute_pipelines(self, pipeline_cache, create_infos, allocator, pipelines) }
	}
}

/// Call `vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html)"]
pub unsafe fn get_device_subpass_shading_max_workgroup_size_huawei(
	device: &Device,
	renderpass: vk::RenderPass,
	p_max_workgroup_size: *mut vk::Extent2D,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_device_subpass_shading_max_workgroup_size_huawei
		.ok_or(CallError::MissingCommand(
			"vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), renderpass, p_max_workgroup_size) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html)"]
	#[inline]
	pub unsafe fn get_device_subpass_shading_max_workgroup_size_huawei(
		&self,
		renderpass: vk::RenderPass,
		p_max_workgroup_size: *mut vk::Extent2D,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_device_subpass_shading_max_workgroup_size_huawei(self, renderpass, p_max_workgroup_size)
		}
	}
}

/// Call `vkDestroyPipeline` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyPipeline` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkDestroyPipeline")]
#[doc = "\n\n[Khronos reference: `vkDestroyPipeline`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyPipeline.html)"]
pub unsafe fn destroy_pipeline(
	device: &Device,
	pipeline: vk::Pipeline,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_pipeline
		.ok_or(CallError::MissingCommand("vkDestroyPipeline"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			pipeline,
			allocator.map_or(std::ptr::null(), |value| value),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkDestroyPipeline` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyPipeline` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkDestroyPipeline")]
	#[doc = "\n\n[Khronos reference: `vkDestroyPipeline`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyPipeline.html)"]
	#[inline]
	pub unsafe fn destroy_pipeline(
		&self,
		pipeline: vk::Pipeline,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_pipeline(self, pipeline, allocator) }
	}
}

/// Call `vkCreatePipelineLayout` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreatePipelineLayout` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCreatePipelineLayout")]
#[doc = "\n\n[Khronos reference: `vkCreatePipelineLayout`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreatePipelineLayout.html)"]
pub unsafe fn create_pipeline_layout(
	device: &Device,
	create_info: &vk::PipelineLayoutCreateInfo<'_>,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<vk::PipelineLayout, CallError> {
	let __vk_function = device
		.fp()
		.create_pipeline_layout
		.ok_or(CallError::MissingCommand("vkCreatePipelineLayout"))?;
	let mut output = vk::PipelineLayout::NULL;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info,
			allocator.map_or(std::ptr::null(), |value| value),
			&mut output,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(output)
}

impl Device {
	/// Call `vkCreatePipelineLayout` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreatePipelineLayout` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCreatePipelineLayout")]
	#[doc = "\n\n[Khronos reference: `vkCreatePipelineLayout`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreatePipelineLayout.html)"]
	#[inline]
	pub unsafe fn create_pipeline_layout(
		&self,
		create_info: &vk::PipelineLayoutCreateInfo<'_>,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<vk::PipelineLayout, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_pipeline_layout(self, create_info, allocator) }
	}
}

/// Call `vkDestroyPipelineLayout` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyPipelineLayout` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkDestroyPipelineLayout")]
#[doc = "\n\n[Khronos reference: `vkDestroyPipelineLayout`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyPipelineLayout.html)"]
pub unsafe fn destroy_pipeline_layout(
	device: &Device,
	pipeline_layout: vk::PipelineLayout,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_pipeline_layout
		.ok_or(CallError::MissingCommand("vkDestroyPipelineLayout"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			pipeline_layout,
			allocator.map_or(std::ptr::null(), |value| value),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkDestroyPipelineLayout` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyPipelineLayout` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkDestroyPipelineLayout")]
	#[doc = "\n\n[Khronos reference: `vkDestroyPipelineLayout`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyPipelineLayout.html)"]
	#[inline]
	pub unsafe fn destroy_pipeline_layout(
		&self,
		pipeline_layout: vk::PipelineLayout,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_pipeline_layout(self, pipeline_layout, allocator) }
	}
}

/// Call `vkCreateSampler` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateSampler` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCreateSampler")]
#[doc = "\n\n[Khronos reference: `vkCreateSampler`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateSampler.html)"]
pub unsafe fn create_sampler(
	device: &Device,
	create_info: &vk::SamplerCreateInfo<'_>,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<vk::Sampler, CallError> {
	let __vk_function = device
		.fp()
		.create_sampler
		.ok_or(CallError::MissingCommand("vkCreateSampler"))?;
	let mut output = vk::Sampler::NULL;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info,
			allocator.map_or(std::ptr::null(), |value| value),
			&mut output,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(output)
}

impl Device {
	/// Call `vkCreateSampler` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateSampler` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCreateSampler")]
	#[doc = "\n\n[Khronos reference: `vkCreateSampler`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateSampler.html)"]
	#[inline]
	pub unsafe fn create_sampler(
		&self,
		create_info: &vk::SamplerCreateInfo<'_>,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<vk::Sampler, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_sampler(self, create_info, allocator) }
	}
}

/// Call `vkDestroySampler` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroySampler` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkDestroySampler")]
#[doc = "\n\n[Khronos reference: `vkDestroySampler`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroySampler.html)"]
pub unsafe fn destroy_sampler(
	device: &Device,
	sampler: vk::Sampler,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_sampler
		.ok_or(CallError::MissingCommand("vkDestroySampler"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			sampler,
			allocator.map_or(std::ptr::null(), |value| value),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkDestroySampler` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroySampler` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkDestroySampler")]
	#[doc = "\n\n[Khronos reference: `vkDestroySampler`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroySampler.html)"]
	#[inline]
	pub unsafe fn destroy_sampler(
		&self,
		sampler: vk::Sampler,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_sampler(self, sampler, allocator) }
	}
}

/// Call `vkCreateDescriptorSetLayout` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateDescriptorSetLayout` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCreateDescriptorSetLayout")]
#[doc = "\n\n[Khronos reference: `vkCreateDescriptorSetLayout`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDescriptorSetLayout.html)"]
pub unsafe fn create_descriptor_set_layout(
	device: &Device,
	create_info: &vk::DescriptorSetLayoutCreateInfo<'_>,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<vk::DescriptorSetLayout, CallError> {
	let __vk_function = device
		.fp()
		.create_descriptor_set_layout
		.ok_or(CallError::MissingCommand("vkCreateDescriptorSetLayout"))?;
	let mut output = vk::DescriptorSetLayout::NULL;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info,
			allocator.map_or(std::ptr::null(), |value| value),
			&mut output,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(output)
}

impl Device {
	/// Call `vkCreateDescriptorSetLayout` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateDescriptorSetLayout` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCreateDescriptorSetLayout")]
	#[doc = "\n\n[Khronos reference: `vkCreateDescriptorSetLayout`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDescriptorSetLayout.html)"]
	#[inline]
	pub unsafe fn create_descriptor_set_layout(
		&self,
		create_info: &vk::DescriptorSetLayoutCreateInfo<'_>,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<vk::DescriptorSetLayout, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_descriptor_set_layout(self, create_info, allocator) }
	}
}

/// Call `vkDestroyDescriptorSetLayout` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyDescriptorSetLayout` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkDestroyDescriptorSetLayout")]
#[doc = "\n\n[Khronos reference: `vkDestroyDescriptorSetLayout`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyDescriptorSetLayout.html)"]
pub unsafe fn destroy_descriptor_set_layout(
	device: &Device,
	descriptor_set_layout: vk::DescriptorSetLayout,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_descriptor_set_layout
		.ok_or(CallError::MissingCommand("vkDestroyDescriptorSetLayout"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			descriptor_set_layout,
			allocator.map_or(std::ptr::null(), |value| value),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkDestroyDescriptorSetLayout` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyDescriptorSetLayout` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkDestroyDescriptorSetLayout")]
	#[doc = "\n\n[Khronos reference: `vkDestroyDescriptorSetLayout`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyDescriptorSetLayout.html)"]
	#[inline]
	pub unsafe fn destroy_descriptor_set_layout(
		&self,
		descriptor_set_layout: vk::DescriptorSetLayout,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_descriptor_set_layout(self, descriptor_set_layout, allocator) }
	}
}

/// Call `vkCreateDescriptorPool` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateDescriptorPool` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCreateDescriptorPool")]
#[doc = "\n\n[Khronos reference: `vkCreateDescriptorPool`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDescriptorPool.html)"]
pub unsafe fn create_descriptor_pool(
	device: &Device,
	create_info: &vk::DescriptorPoolCreateInfo<'_>,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<vk::DescriptorPool, CallError> {
	let __vk_function = device
		.fp()
		.create_descriptor_pool
		.ok_or(CallError::MissingCommand("vkCreateDescriptorPool"))?;
	let mut output = vk::DescriptorPool::NULL;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info,
			allocator.map_or(std::ptr::null(), |value| value),
			&mut output,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(output)
}

impl Device {
	/// Call `vkCreateDescriptorPool` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateDescriptorPool` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCreateDescriptorPool")]
	#[doc = "\n\n[Khronos reference: `vkCreateDescriptorPool`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDescriptorPool.html)"]
	#[inline]
	pub unsafe fn create_descriptor_pool(
		&self,
		create_info: &vk::DescriptorPoolCreateInfo<'_>,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<vk::DescriptorPool, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_descriptor_pool(self, create_info, allocator) }
	}
}

/// Call `vkDestroyDescriptorPool` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyDescriptorPool` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkDestroyDescriptorPool")]
#[doc = "\n\n[Khronos reference: `vkDestroyDescriptorPool`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyDescriptorPool.html)"]
pub unsafe fn destroy_descriptor_pool(
	device: &Device,
	descriptor_pool: vk::DescriptorPool,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_descriptor_pool
		.ok_or(CallError::MissingCommand("vkDestroyDescriptorPool"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			descriptor_pool,
			allocator.map_or(std::ptr::null(), |value| value),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkDestroyDescriptorPool` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyDescriptorPool` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkDestroyDescriptorPool")]
	#[doc = "\n\n[Khronos reference: `vkDestroyDescriptorPool`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyDescriptorPool.html)"]
	#[inline]
	pub unsafe fn destroy_descriptor_pool(
		&self,
		descriptor_pool: vk::DescriptorPool,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_descriptor_pool(self, descriptor_pool, allocator) }
	}
}

/// Call `vkResetDescriptorPool` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkResetDescriptorPool` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkResetDescriptorPool")]
#[doc = "\n\n[Khronos reference: `vkResetDescriptorPool`](https://docs.vulkan.org/refpages/latest/refpages/source/vkResetDescriptorPool.html)"]
pub unsafe fn reset_descriptor_pool(
	device: &Device,
	descriptor_pool: vk::DescriptorPool,
	flags: vk::DescriptorPoolResetFlags,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.reset_descriptor_pool
		.ok_or(CallError::MissingCommand("vkResetDescriptorPool"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), descriptor_pool, flags) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkResetDescriptorPool` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkResetDescriptorPool` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkResetDescriptorPool")]
	#[doc = "\n\n[Khronos reference: `vkResetDescriptorPool`](https://docs.vulkan.org/refpages/latest/refpages/source/vkResetDescriptorPool.html)"]
	#[inline]
	pub unsafe fn reset_descriptor_pool(
		&self,
		descriptor_pool: vk::DescriptorPool,
		flags: vk::DescriptorPoolResetFlags,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { reset_descriptor_pool(self, descriptor_pool, flags) }
	}
}

/// Call `vkAllocateDescriptorSets` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkAllocateDescriptorSets` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkAllocateDescriptorSets")]
#[doc = "\n\n[Khronos reference: `vkAllocateDescriptorSets`](https://docs.vulkan.org/refpages/latest/refpages/source/vkAllocateDescriptorSets.html)"]
pub unsafe fn allocate_descriptor_sets(
	device: &Device,
	allocate_info: &vk::DescriptorSetAllocateInfo<'_>,
	descriptor_sets: &mut [vk::DescriptorSet],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.allocate_descriptor_sets
		.ok_or(CallError::MissingCommand("vkAllocateDescriptorSets"))?;
	let descriptor_sets_expected = usize::try_from(allocate_info.descriptor_set_count)
		.map_err(|_| CallError::CountOverflow(usize::MAX))?;
	if descriptor_sets.len() != descriptor_sets_expected {
		return Err(CallError::SliceLengthMismatch {
			parameter: "descriptor_sets",
			expected: descriptor_sets_expected,
			actual: descriptor_sets.len(),
		});
	}
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result =
		unsafe { __vk_function(device.handle(), allocate_info, descriptor_sets.as_mut_ptr()) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkAllocateDescriptorSets` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkAllocateDescriptorSets` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkAllocateDescriptorSets")]
	#[doc = "\n\n[Khronos reference: `vkAllocateDescriptorSets`](https://docs.vulkan.org/refpages/latest/refpages/source/vkAllocateDescriptorSets.html)"]
	#[inline]
	pub unsafe fn allocate_descriptor_sets(
		&self,
		allocate_info: &vk::DescriptorSetAllocateInfo<'_>,
		descriptor_sets: &mut [vk::DescriptorSet],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { allocate_descriptor_sets(self, allocate_info, descriptor_sets) }
	}
}

/// Call `vkFreeDescriptorSets` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkFreeDescriptorSets` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkFreeDescriptorSets")]
#[doc = "\n\n[Khronos reference: `vkFreeDescriptorSets`](https://docs.vulkan.org/refpages/latest/refpages/source/vkFreeDescriptorSets.html)"]
pub unsafe fn free_descriptor_sets(
	device: &Device,
	descriptor_pool: vk::DescriptorPool,
	descriptor_sets: &[vk::DescriptorSet],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.free_descriptor_sets
		.ok_or(CallError::MissingCommand("vkFreeDescriptorSets"))?;
	let descriptor_set_count = u32::try_from(descriptor_sets.len())
		.map_err(|_| CallError::CountOverflow(descriptor_sets.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			descriptor_pool,
			descriptor_set_count,
			descriptor_sets.as_ptr(),
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkFreeDescriptorSets` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkFreeDescriptorSets` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkFreeDescriptorSets")]
	#[doc = "\n\n[Khronos reference: `vkFreeDescriptorSets`](https://docs.vulkan.org/refpages/latest/refpages/source/vkFreeDescriptorSets.html)"]
	#[inline]
	pub unsafe fn free_descriptor_sets(
		&self,
		descriptor_pool: vk::DescriptorPool,
		descriptor_sets: &[vk::DescriptorSet],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { free_descriptor_sets(self, descriptor_pool, descriptor_sets) }
	}
}

/// Call `vkUpdateDescriptorSets` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkUpdateDescriptorSets` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkUpdateDescriptorSets")]
#[doc = "\n\n[Khronos reference: `vkUpdateDescriptorSets`](https://docs.vulkan.org/refpages/latest/refpages/source/vkUpdateDescriptorSets.html)"]
pub unsafe fn update_descriptor_sets(
	device: &Device,
	descriptor_writes: &[vk::WriteDescriptorSet<'_>],
	descriptor_copies: &[vk::CopyDescriptorSet<'_>],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.update_descriptor_sets
		.ok_or(CallError::MissingCommand("vkUpdateDescriptorSets"))?;
	let descriptor_write_count = u32::try_from(descriptor_writes.len())
		.map_err(|_| CallError::CountOverflow(descriptor_writes.len()))?;
	let descriptor_copy_count = u32::try_from(descriptor_copies.len())
		.map_err(|_| CallError::CountOverflow(descriptor_copies.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			descriptor_write_count,
			descriptor_writes.as_ptr(),
			descriptor_copy_count,
			descriptor_copies.as_ptr(),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkUpdateDescriptorSets` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkUpdateDescriptorSets` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkUpdateDescriptorSets")]
	#[doc = "\n\n[Khronos reference: `vkUpdateDescriptorSets`](https://docs.vulkan.org/refpages/latest/refpages/source/vkUpdateDescriptorSets.html)"]
	#[inline]
	pub unsafe fn update_descriptor_sets(
		&self,
		descriptor_writes: &[vk::WriteDescriptorSet<'_>],
		descriptor_copies: &[vk::CopyDescriptorSet<'_>],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { update_descriptor_sets(self, descriptor_writes, descriptor_copies) }
	}
}

/// Call `vkCreateFramebuffer` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateFramebuffer` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCreateFramebuffer")]
#[doc = "\n\n[Khronos reference: `vkCreateFramebuffer`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateFramebuffer.html)"]
pub unsafe fn create_framebuffer(
	device: &Device,
	create_info: &vk::FramebufferCreateInfo<'_>,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<vk::Framebuffer, CallError> {
	let __vk_function = device
		.fp()
		.create_framebuffer
		.ok_or(CallError::MissingCommand("vkCreateFramebuffer"))?;
	let mut output = vk::Framebuffer::NULL;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info,
			allocator.map_or(std::ptr::null(), |value| value),
			&mut output,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(output)
}

impl Device {
	/// Call `vkCreateFramebuffer` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateFramebuffer` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCreateFramebuffer")]
	#[doc = "\n\n[Khronos reference: `vkCreateFramebuffer`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateFramebuffer.html)"]
	#[inline]
	pub unsafe fn create_framebuffer(
		&self,
		create_info: &vk::FramebufferCreateInfo<'_>,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<vk::Framebuffer, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_framebuffer(self, create_info, allocator) }
	}
}

/// Call `vkDestroyFramebuffer` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyFramebuffer` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkDestroyFramebuffer")]
#[doc = "\n\n[Khronos reference: `vkDestroyFramebuffer`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyFramebuffer.html)"]
pub unsafe fn destroy_framebuffer(
	device: &Device,
	framebuffer: vk::Framebuffer,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_framebuffer
		.ok_or(CallError::MissingCommand("vkDestroyFramebuffer"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			framebuffer,
			allocator.map_or(std::ptr::null(), |value| value),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkDestroyFramebuffer` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyFramebuffer` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkDestroyFramebuffer")]
	#[doc = "\n\n[Khronos reference: `vkDestroyFramebuffer`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyFramebuffer.html)"]
	#[inline]
	pub unsafe fn destroy_framebuffer(
		&self,
		framebuffer: vk::Framebuffer,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_framebuffer(self, framebuffer, allocator) }
	}
}

/// Call `vkCreateRenderPass` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateRenderPass` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCreateRenderPass")]
#[doc = "\n\n[Khronos reference: `vkCreateRenderPass`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateRenderPass.html)"]
pub unsafe fn create_render_pass(
	device: &Device,
	create_info: &vk::RenderPassCreateInfo<'_>,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<vk::RenderPass, CallError> {
	let __vk_function = device
		.fp()
		.create_render_pass
		.ok_or(CallError::MissingCommand("vkCreateRenderPass"))?;
	let mut output = vk::RenderPass::NULL;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info,
			allocator.map_or(std::ptr::null(), |value| value),
			&mut output,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(output)
}

impl Device {
	/// Call `vkCreateRenderPass` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateRenderPass` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCreateRenderPass")]
	#[doc = "\n\n[Khronos reference: `vkCreateRenderPass`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateRenderPass.html)"]
	#[inline]
	pub unsafe fn create_render_pass(
		&self,
		create_info: &vk::RenderPassCreateInfo<'_>,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<vk::RenderPass, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_render_pass(self, create_info, allocator) }
	}
}

/// Call `vkDestroyRenderPass` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyRenderPass` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkDestroyRenderPass")]
#[doc = "\n\n[Khronos reference: `vkDestroyRenderPass`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyRenderPass.html)"]
pub unsafe fn destroy_render_pass(
	device: &Device,
	render_pass: vk::RenderPass,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_render_pass
		.ok_or(CallError::MissingCommand("vkDestroyRenderPass"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			render_pass,
			allocator.map_or(std::ptr::null(), |value| value),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkDestroyRenderPass` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyRenderPass` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkDestroyRenderPass")]
	#[doc = "\n\n[Khronos reference: `vkDestroyRenderPass`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyRenderPass.html)"]
	#[inline]
	pub unsafe fn destroy_render_pass(
		&self,
		render_pass: vk::RenderPass,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_render_pass(self, render_pass, allocator) }
	}
}

/// Call `vkGetRenderAreaGranularity` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetRenderAreaGranularity` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetRenderAreaGranularity")]
#[doc = "\n\n[Khronos reference: `vkGetRenderAreaGranularity`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetRenderAreaGranularity.html)"]
pub unsafe fn get_render_area_granularity(
	device: &Device,
	render_pass: vk::RenderPass,
	granularity: &mut vk::Extent2D,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_render_area_granularity
		.ok_or(CallError::MissingCommand("vkGetRenderAreaGranularity"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), render_pass, granularity) };
	Ok(())
}

impl Device {
	/// Call `vkGetRenderAreaGranularity` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetRenderAreaGranularity` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetRenderAreaGranularity")]
	#[doc = "\n\n[Khronos reference: `vkGetRenderAreaGranularity`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetRenderAreaGranularity.html)"]
	#[inline]
	pub unsafe fn get_render_area_granularity(
		&self,
		render_pass: vk::RenderPass,
		granularity: &mut vk::Extent2D,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_render_area_granularity(self, render_pass, granularity) }
	}
}

/// Call `vkGetRenderingAreaGranularity` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetRenderingAreaGranularity` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetRenderingAreaGranularity")]
#[doc = "\n\n[Khronos reference: `vkGetRenderingAreaGranularity`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetRenderingAreaGranularity.html)"]
pub unsafe fn get_rendering_area_granularity(
	device: &Device,
	p_rendering_area_info: *const vk::RenderingAreaInfo<'_>,
	p_granularity: *mut vk::Extent2D,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_rendering_area_granularity
		.ok_or(CallError::MissingCommand("vkGetRenderingAreaGranularity"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_rendering_area_info, p_granularity) };
	Ok(())
}

impl Device {
	/// Call `vkGetRenderingAreaGranularity` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetRenderingAreaGranularity` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetRenderingAreaGranularity")]
	#[doc = "\n\n[Khronos reference: `vkGetRenderingAreaGranularity`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetRenderingAreaGranularity.html)"]
	#[inline]
	pub unsafe fn get_rendering_area_granularity(
		&self,
		p_rendering_area_info: *const vk::RenderingAreaInfo<'_>,
		p_granularity: *mut vk::Extent2D,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_rendering_area_granularity(self, p_rendering_area_info, p_granularity) }
	}
}

/// Call `vkGetRenderingAreaGranularityKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetRenderingAreaGranularityKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetRenderingAreaGranularityKHR")]
#[doc = "\n\n[Khronos reference: `vkGetRenderingAreaGranularityKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetRenderingAreaGranularityKHR.html)"]
pub unsafe fn get_rendering_area_granularity_khr(
	device: &Device,
	p_rendering_area_info: *const vk::RenderingAreaInfo<'_>,
	p_granularity: *mut vk::Extent2D,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.get_rendering_area_granularity_khr
			.ok_or(CallError::MissingCommand(
				"vkGetRenderingAreaGranularityKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_rendering_area_info, p_granularity) };
	Ok(())
}

impl Device {
	/// Call `vkGetRenderingAreaGranularityKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetRenderingAreaGranularityKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetRenderingAreaGranularityKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetRenderingAreaGranularityKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetRenderingAreaGranularityKHR.html)"]
	#[inline]
	pub unsafe fn get_rendering_area_granularity_khr(
		&self,
		p_rendering_area_info: *const vk::RenderingAreaInfo<'_>,
		p_granularity: *mut vk::Extent2D,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_rendering_area_granularity_khr(self, p_rendering_area_info, p_granularity) }
	}
}

/// Call `vkResetCommandPool` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkResetCommandPool` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkResetCommandPool")]
#[doc = "\n\n[Khronos reference: `vkResetCommandPool`](https://docs.vulkan.org/refpages/latest/refpages/source/vkResetCommandPool.html)"]
pub unsafe fn reset_command_pool(
	device: &Device,
	command_pool: vk::CommandPool,
	flags: vk::CommandPoolResetFlags,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.reset_command_pool
		.ok_or(CallError::MissingCommand("vkResetCommandPool"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), command_pool, flags) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkResetCommandPool` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkResetCommandPool` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkResetCommandPool")]
	#[doc = "\n\n[Khronos reference: `vkResetCommandPool`](https://docs.vulkan.org/refpages/latest/refpages/source/vkResetCommandPool.html)"]
	#[inline]
	pub unsafe fn reset_command_pool(
		&self,
		command_pool: vk::CommandPool,
		flags: vk::CommandPoolResetFlags,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { reset_command_pool(self, command_pool, flags) }
	}
}

/// Call `vkResetCommandBuffer` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkResetCommandBuffer` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkResetCommandBuffer")]
#[doc = "\n\n[Khronos reference: `vkResetCommandBuffer`](https://docs.vulkan.org/refpages/latest/refpages/source/vkResetCommandBuffer.html)"]
pub unsafe fn reset_command_buffer(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	flags: vk::CommandBufferResetFlags,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.reset_command_buffer
		.ok_or(CallError::MissingCommand("vkResetCommandBuffer"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(command_buffer, flags) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkResetCommandBuffer` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkResetCommandBuffer` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkResetCommandBuffer")]
	#[doc = "\n\n[Khronos reference: `vkResetCommandBuffer`](https://docs.vulkan.org/refpages/latest/refpages/source/vkResetCommandBuffer.html)"]
	#[inline]
	pub unsafe fn reset_command_buffer(
		&self,
		command_buffer: vk::CommandBuffer,
		flags: vk::CommandBufferResetFlags,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { reset_command_buffer(self, command_buffer, flags) }
	}
}

/// Call `vkCmdBindPipeline` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindPipeline` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdBindPipeline")]
#[doc = "\n\n[Khronos reference: `vkCmdBindPipeline`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindPipeline.html)"]
pub unsafe fn cmd_bind_pipeline(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	pipeline_bind_point: vk::PipelineBindPoint,
	pipeline: vk::Pipeline,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_pipeline
		.ok_or(CallError::MissingCommand("vkCmdBindPipeline"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, pipeline_bind_point, pipeline) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBindPipeline` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindPipeline` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdBindPipeline")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindPipeline`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindPipeline.html)"]
	#[inline]
	pub unsafe fn cmd_bind_pipeline(
		&self,
		command_buffer: vk::CommandBuffer,
		pipeline_bind_point: vk::PipelineBindPoint,
		pipeline: vk::Pipeline,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_bind_pipeline(self, command_buffer, pipeline_bind_point, pipeline) }
	}
}

/// Call `vkCmdSetPrimitiveRestartIndexEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetPrimitiveRestartIndexEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetPrimitiveRestartIndexEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetPrimitiveRestartIndexEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetPrimitiveRestartIndexEXT.html)"]
pub unsafe fn cmd_set_primitive_restart_index_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	primitive_restart_index: u32,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_primitive_restart_index_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdSetPrimitiveRestartIndexEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, primitive_restart_index) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetPrimitiveRestartIndexEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetPrimitiveRestartIndexEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetPrimitiveRestartIndexEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetPrimitiveRestartIndexEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetPrimitiveRestartIndexEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_primitive_restart_index_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		primitive_restart_index: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_primitive_restart_index_ext(self, command_buffer, primitive_restart_index) }
	}
}

/// Call `vkCmdSetAttachmentFeedbackLoopEnableEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetAttachmentFeedbackLoopEnableEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetAttachmentFeedbackLoopEnableEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetAttachmentFeedbackLoopEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetAttachmentFeedbackLoopEnableEXT.html)"]
pub unsafe fn cmd_set_attachment_feedback_loop_enable_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	aspect_mask: vk::ImageAspectFlags,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_attachment_feedback_loop_enable_ext
		.ok_or(CallError::MissingCommand(
			"vkCmdSetAttachmentFeedbackLoopEnableEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, aspect_mask) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetAttachmentFeedbackLoopEnableEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetAttachmentFeedbackLoopEnableEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetAttachmentFeedbackLoopEnableEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetAttachmentFeedbackLoopEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetAttachmentFeedbackLoopEnableEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_attachment_feedback_loop_enable_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		aspect_mask: vk::ImageAspectFlags,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_attachment_feedback_loop_enable_ext(self, command_buffer, aspect_mask) }
	}
}

/// Call `vkCmdSetViewport` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetViewport` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdSetViewport")]
#[doc = "\n\n[Khronos reference: `vkCmdSetViewport`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetViewport.html)"]
pub unsafe fn cmd_set_viewport(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_viewport: u32,
	viewports: &[vk::Viewport],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_viewport
		.ok_or(CallError::MissingCommand("vkCmdSetViewport"))?;
	let viewport_count =
		u32::try_from(viewports.len()).map_err(|_| CallError::CountOverflow(viewports.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_viewport,
			viewport_count,
			viewports.as_ptr(),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdSetViewport` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetViewport` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdSetViewport")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetViewport`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetViewport.html)"]
	#[inline]
	pub unsafe fn cmd_set_viewport(
		&self,
		command_buffer: vk::CommandBuffer,
		first_viewport: u32,
		viewports: &[vk::Viewport],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_viewport(self, command_buffer, first_viewport, viewports) }
	}
}

/// Call `vkCmdSetScissor` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetScissor` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdSetScissor")]
#[doc = "\n\n[Khronos reference: `vkCmdSetScissor`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetScissor.html)"]
pub unsafe fn cmd_set_scissor(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_scissor: u32,
	scissors: &[vk::Rect2D],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_scissor
		.ok_or(CallError::MissingCommand("vkCmdSetScissor"))?;
	let scissor_count =
		u32::try_from(scissors.len()).map_err(|_| CallError::CountOverflow(scissors.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_scissor,
			scissor_count,
			scissors.as_ptr(),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdSetScissor` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetScissor` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdSetScissor")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetScissor`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetScissor.html)"]
	#[inline]
	pub unsafe fn cmd_set_scissor(
		&self,
		command_buffer: vk::CommandBuffer,
		first_scissor: u32,
		scissors: &[vk::Rect2D],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_scissor(self, command_buffer, first_scissor, scissors) }
	}
}

/// Call `vkCmdSetLineWidth` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetLineWidth` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdSetLineWidth")]
#[doc = "\n\n[Khronos reference: `vkCmdSetLineWidth`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetLineWidth.html)"]
pub unsafe fn cmd_set_line_width(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	line_width: f32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_line_width
		.ok_or(CallError::MissingCommand("vkCmdSetLineWidth"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, line_width) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetLineWidth` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetLineWidth` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdSetLineWidth")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetLineWidth`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetLineWidth.html)"]
	#[inline]
	pub unsafe fn cmd_set_line_width(
		&self,
		command_buffer: vk::CommandBuffer,
		line_width: f32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_line_width(self, command_buffer, line_width) }
	}
}

/// Call `vkCmdSetDepthBias` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDepthBias` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdSetDepthBias")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDepthBias`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthBias.html)"]
pub unsafe fn cmd_set_depth_bias(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	depth_bias_constant_factor: f32,
	depth_bias_clamp: f32,
	depth_bias_slope_factor: f32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_depth_bias
		.ok_or(CallError::MissingCommand("vkCmdSetDepthBias"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			depth_bias_constant_factor,
			depth_bias_clamp,
			depth_bias_slope_factor,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDepthBias` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDepthBias` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdSetDepthBias")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDepthBias`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthBias.html)"]
	#[inline]
	pub unsafe fn cmd_set_depth_bias(
		&self,
		command_buffer: vk::CommandBuffer,
		depth_bias_constant_factor: f32,
		depth_bias_clamp: f32,
		depth_bias_slope_factor: f32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_depth_bias(
				self,
				command_buffer,
				depth_bias_constant_factor,
				depth_bias_clamp,
				depth_bias_slope_factor,
			)
		}
	}
}

/// Call `vkCmdSetBlendConstants` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetBlendConstants` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdSetBlendConstants")]
#[doc = "\n\n[Khronos reference: `vkCmdSetBlendConstants`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetBlendConstants.html)"]
pub unsafe fn cmd_set_blend_constants(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	blend_constants: &[f32; 4],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_blend_constants
		.ok_or(CallError::MissingCommand("vkCmdSetBlendConstants"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, blend_constants.as_ptr()) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetBlendConstants` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetBlendConstants` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdSetBlendConstants")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetBlendConstants`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetBlendConstants.html)"]
	#[inline]
	pub unsafe fn cmd_set_blend_constants(
		&self,
		command_buffer: vk::CommandBuffer,
		blend_constants: &[f32; 4],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_blend_constants(self, command_buffer, blend_constants) }
	}
}

/// Call `vkCmdSetDepthBounds` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDepthBounds` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdSetDepthBounds")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDepthBounds`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthBounds.html)"]
pub unsafe fn cmd_set_depth_bounds(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	min_depth_bounds: f32,
	max_depth_bounds: f32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_depth_bounds
		.ok_or(CallError::MissingCommand("vkCmdSetDepthBounds"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, min_depth_bounds, max_depth_bounds) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDepthBounds` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDepthBounds` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdSetDepthBounds")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDepthBounds`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthBounds.html)"]
	#[inline]
	pub unsafe fn cmd_set_depth_bounds(
		&self,
		command_buffer: vk::CommandBuffer,
		min_depth_bounds: f32,
		max_depth_bounds: f32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_depth_bounds(self, command_buffer, min_depth_bounds, max_depth_bounds) }
	}
}

/// Call `vkCmdSetStencilCompareMask` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetStencilCompareMask` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdSetStencilCompareMask")]
#[doc = "\n\n[Khronos reference: `vkCmdSetStencilCompareMask`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetStencilCompareMask.html)"]
pub unsafe fn cmd_set_stencil_compare_mask(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	face_mask: vk::StencilFaceFlags,
	compare_mask: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_stencil_compare_mask
		.ok_or(CallError::MissingCommand("vkCmdSetStencilCompareMask"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, face_mask, compare_mask) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetStencilCompareMask` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetStencilCompareMask` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdSetStencilCompareMask")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetStencilCompareMask`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetStencilCompareMask.html)"]
	#[inline]
	pub unsafe fn cmd_set_stencil_compare_mask(
		&self,
		command_buffer: vk::CommandBuffer,
		face_mask: vk::StencilFaceFlags,
		compare_mask: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_stencil_compare_mask(self, command_buffer, face_mask, compare_mask) }
	}
}

/// Call `vkCmdSetStencilWriteMask` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetStencilWriteMask` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdSetStencilWriteMask")]
#[doc = "\n\n[Khronos reference: `vkCmdSetStencilWriteMask`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetStencilWriteMask.html)"]
pub unsafe fn cmd_set_stencil_write_mask(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	face_mask: vk::StencilFaceFlags,
	write_mask: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_stencil_write_mask
		.ok_or(CallError::MissingCommand("vkCmdSetStencilWriteMask"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, face_mask, write_mask) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetStencilWriteMask` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetStencilWriteMask` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdSetStencilWriteMask")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetStencilWriteMask`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetStencilWriteMask.html)"]
	#[inline]
	pub unsafe fn cmd_set_stencil_write_mask(
		&self,
		command_buffer: vk::CommandBuffer,
		face_mask: vk::StencilFaceFlags,
		write_mask: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_stencil_write_mask(self, command_buffer, face_mask, write_mask) }
	}
}

/// Call `vkCmdSetStencilReference` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetStencilReference` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdSetStencilReference")]
#[doc = "\n\n[Khronos reference: `vkCmdSetStencilReference`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetStencilReference.html)"]
pub unsafe fn cmd_set_stencil_reference(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	face_mask: vk::StencilFaceFlags,
	reference: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_stencil_reference
		.ok_or(CallError::MissingCommand("vkCmdSetStencilReference"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, face_mask, reference) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetStencilReference` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetStencilReference` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdSetStencilReference")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetStencilReference`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetStencilReference.html)"]
	#[inline]
	pub unsafe fn cmd_set_stencil_reference(
		&self,
		command_buffer: vk::CommandBuffer,
		face_mask: vk::StencilFaceFlags,
		reference: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_stencil_reference(self, command_buffer, face_mask, reference) }
	}
}

/// Call `vkCmdBindDescriptorSets` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindDescriptorSets` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdBindDescriptorSets")]
#[doc = "\n\n[Khronos reference: `vkCmdBindDescriptorSets`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindDescriptorSets.html)"]
pub unsafe fn cmd_bind_descriptor_sets(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	pipeline_bind_point: vk::PipelineBindPoint,
	layout: vk::PipelineLayout,
	first_set: u32,
	descriptor_sets: &[vk::DescriptorSet],
	dynamic_offsets: &[u32],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_descriptor_sets
		.ok_or(CallError::MissingCommand("vkCmdBindDescriptorSets"))?;
	let descriptor_set_count = u32::try_from(descriptor_sets.len())
		.map_err(|_| CallError::CountOverflow(descriptor_sets.len()))?;
	let dynamic_offset_count = u32::try_from(dynamic_offsets.len())
		.map_err(|_| CallError::CountOverflow(dynamic_offsets.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			pipeline_bind_point,
			layout,
			first_set,
			descriptor_set_count,
			descriptor_sets.as_ptr(),
			dynamic_offset_count,
			dynamic_offsets.as_ptr(),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdBindDescriptorSets` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindDescriptorSets` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdBindDescriptorSets")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindDescriptorSets`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindDescriptorSets.html)"]
	#[inline]
	pub unsafe fn cmd_bind_descriptor_sets(
		&self,
		command_buffer: vk::CommandBuffer,
		pipeline_bind_point: vk::PipelineBindPoint,
		layout: vk::PipelineLayout,
		first_set: u32,
		descriptor_sets: &[vk::DescriptorSet],
		dynamic_offsets: &[u32],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_bind_descriptor_sets(
				self,
				command_buffer,
				pipeline_bind_point,
				layout,
				first_set,
				descriptor_sets,
				dynamic_offsets,
			)
		}
	}
}

/// Call `vkCmdBindIndexBuffer` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindIndexBuffer` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdBindIndexBuffer")]
#[doc = "\n\n[Khronos reference: `vkCmdBindIndexBuffer`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindIndexBuffer.html)"]
pub unsafe fn cmd_bind_index_buffer(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	buffer: vk::Buffer,
	offset: vk::DeviceSize,
	index_type: vk::IndexType,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_index_buffer
		.ok_or(CallError::MissingCommand("vkCmdBindIndexBuffer"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, buffer, offset, index_type) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBindIndexBuffer` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindIndexBuffer` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdBindIndexBuffer")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindIndexBuffer`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindIndexBuffer.html)"]
	#[inline]
	pub unsafe fn cmd_bind_index_buffer(
		&self,
		command_buffer: vk::CommandBuffer,
		buffer: vk::Buffer,
		offset: vk::DeviceSize,
		index_type: vk::IndexType,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_bind_index_buffer(self, command_buffer, buffer, offset, index_type) }
	}
}

/// Call `vkCmdBindVertexBuffers` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindVertexBuffers` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdBindVertexBuffers")]
#[doc = "\n\n[Khronos reference: `vkCmdBindVertexBuffers`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindVertexBuffers.html)"]
pub unsafe fn cmd_bind_vertex_buffers(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_binding: u32,
	buffers: &[vk::Buffer],
	offsets: &[vk::DeviceSize],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_vertex_buffers
		.ok_or(CallError::MissingCommand("vkCmdBindVertexBuffers"))?;
	let binding_count =
		u32::try_from(buffers.len()).map_err(|_| CallError::CountOverflow(buffers.len()))?;
	if offsets.len() != buffers.len() {
		return Err(CallError::SliceLengthMismatch {
			parameter: "offsets",
			expected: buffers.len(),
			actual: offsets.len(),
		});
	}
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_binding,
			binding_count,
			buffers.as_ptr(),
			offsets.as_ptr(),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdBindVertexBuffers` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindVertexBuffers` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdBindVertexBuffers")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindVertexBuffers`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindVertexBuffers.html)"]
	#[inline]
	pub unsafe fn cmd_bind_vertex_buffers(
		&self,
		command_buffer: vk::CommandBuffer,
		first_binding: u32,
		buffers: &[vk::Buffer],
		offsets: &[vk::DeviceSize],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_bind_vertex_buffers(self, command_buffer, first_binding, buffers, offsets) }
	}
}

/// Call `vkCmdDraw` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDraw` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdDraw")]
#[doc = "\n\n[Khronos reference: `vkCmdDraw`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDraw.html)"]
pub unsafe fn cmd_draw(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	vertex_count: u32,
	instance_count: u32,
	first_vertex: u32,
	first_instance: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw
		.ok_or(CallError::MissingCommand("vkCmdDraw"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			vertex_count,
			instance_count,
			first_vertex,
			first_instance,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdDraw` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDraw` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdDraw")]
	#[doc = "\n\n[Khronos reference: `vkCmdDraw`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDraw.html)"]
	#[inline]
	pub unsafe fn cmd_draw(
		&self,
		command_buffer: vk::CommandBuffer,
		vertex_count: u32,
		instance_count: u32,
		first_vertex: u32,
		first_instance: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_draw(
				self,
				command_buffer,
				vertex_count,
				instance_count,
				first_vertex,
				first_instance,
			)
		}
	}
}

/// Call `vkCmdDrawIndexed` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawIndexed` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdDrawIndexed")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawIndexed`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndexed.html)"]
pub unsafe fn cmd_draw_indexed(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	index_count: u32,
	instance_count: u32,
	first_index: u32,
	vertex_offset: i32,
	first_instance: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_indexed
		.ok_or(CallError::MissingCommand("vkCmdDrawIndexed"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			index_count,
			instance_count,
			first_index,
			vertex_offset,
			first_instance,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawIndexed` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawIndexed` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdDrawIndexed")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawIndexed`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndexed.html)"]
	#[inline]
	pub unsafe fn cmd_draw_indexed(
		&self,
		command_buffer: vk::CommandBuffer,
		index_count: u32,
		instance_count: u32,
		first_index: u32,
		vertex_offset: i32,
		first_instance: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_draw_indexed(
				self,
				command_buffer,
				index_count,
				instance_count,
				first_index,
				vertex_offset,
				first_instance,
			)
		}
	}
}

/// Call `vkCmdDrawMultiEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawMultiEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDrawMultiEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawMultiEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawMultiEXT.html)"]
pub unsafe fn cmd_draw_multi_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	draw_count: u32,
	p_vertex_info: *const vk::MultiDrawInfoEXT,
	instance_count: u32,
	first_instance: u32,
	stride: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_multi_ext
		.ok_or(CallError::MissingCommand("vkCmdDrawMultiEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			draw_count,
			p_vertex_info,
			instance_count,
			first_instance,
			stride,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawMultiEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawMultiEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDrawMultiEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawMultiEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawMultiEXT.html)"]
	#[inline]
	pub unsafe fn cmd_draw_multi_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		draw_count: u32,
		p_vertex_info: *const vk::MultiDrawInfoEXT,
		instance_count: u32,
		first_instance: u32,
		stride: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_draw_multi_ext(
				self,
				command_buffer,
				draw_count,
				p_vertex_info,
				instance_count,
				first_instance,
				stride,
			)
		}
	}
}

/// Call `vkCmdDrawMultiIndexedEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawMultiIndexedEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDrawMultiIndexedEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawMultiIndexedEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawMultiIndexedEXT.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_draw_multi_indexed_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	draw_count: u32,
	p_index_info: *const vk::MultiDrawIndexedInfoEXT,
	instance_count: u32,
	first_instance: u32,
	stride: u32,
	p_vertex_offset: *const i32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_multi_indexed_ext
		.ok_or(CallError::MissingCommand("vkCmdDrawMultiIndexedEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			draw_count,
			p_index_info,
			instance_count,
			first_instance,
			stride,
			p_vertex_offset,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawMultiIndexedEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawMultiIndexedEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDrawMultiIndexedEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawMultiIndexedEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawMultiIndexedEXT.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_draw_multi_indexed_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		draw_count: u32,
		p_index_info: *const vk::MultiDrawIndexedInfoEXT,
		instance_count: u32,
		first_instance: u32,
		stride: u32,
		p_vertex_offset: *const i32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_draw_multi_indexed_ext(
				self,
				command_buffer,
				draw_count,
				p_index_info,
				instance_count,
				first_instance,
				stride,
				p_vertex_offset,
			)
		}
	}
}

/// Call `vkCmdDrawIndirect` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawIndirect` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdDrawIndirect")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawIndirect`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndirect.html)"]
pub unsafe fn cmd_draw_indirect(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	buffer: vk::Buffer,
	offset: vk::DeviceSize,
	draw_count: u32,
	stride: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_indirect
		.ok_or(CallError::MissingCommand("vkCmdDrawIndirect"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, buffer, offset, draw_count, stride) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawIndirect` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawIndirect` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdDrawIndirect")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawIndirect`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndirect.html)"]
	#[inline]
	pub unsafe fn cmd_draw_indirect(
		&self,
		command_buffer: vk::CommandBuffer,
		buffer: vk::Buffer,
		offset: vk::DeviceSize,
		draw_count: u32,
		stride: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_draw_indirect(self, command_buffer, buffer, offset, draw_count, stride) }
	}
}

/// Call `vkCmdDrawIndexedIndirect` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawIndexedIndirect` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdDrawIndexedIndirect")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawIndexedIndirect`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndexedIndirect.html)"]
pub unsafe fn cmd_draw_indexed_indirect(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	buffer: vk::Buffer,
	offset: vk::DeviceSize,
	draw_count: u32,
	stride: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_indexed_indirect
		.ok_or(CallError::MissingCommand("vkCmdDrawIndexedIndirect"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, buffer, offset, draw_count, stride) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawIndexedIndirect` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawIndexedIndirect` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdDrawIndexedIndirect")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawIndexedIndirect`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndexedIndirect.html)"]
	#[inline]
	pub unsafe fn cmd_draw_indexed_indirect(
		&self,
		command_buffer: vk::CommandBuffer,
		buffer: vk::Buffer,
		offset: vk::DeviceSize,
		draw_count: u32,
		stride: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_draw_indexed_indirect(self, command_buffer, buffer, offset, draw_count, stride) }
	}
}

/// Call `vkCmdDispatchIndirect` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDispatchIndirect` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdDispatchIndirect")]
#[doc = "\n\n[Khronos reference: `vkCmdDispatchIndirect`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDispatchIndirect.html)"]
pub unsafe fn cmd_dispatch_indirect(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	buffer: vk::Buffer,
	offset: vk::DeviceSize,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_dispatch_indirect
		.ok_or(CallError::MissingCommand("vkCmdDispatchIndirect"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, buffer, offset) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDispatchIndirect` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDispatchIndirect` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdDispatchIndirect")]
	#[doc = "\n\n[Khronos reference: `vkCmdDispatchIndirect`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDispatchIndirect.html)"]
	#[inline]
	pub unsafe fn cmd_dispatch_indirect(
		&self,
		command_buffer: vk::CommandBuffer,
		buffer: vk::Buffer,
		offset: vk::DeviceSize,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_dispatch_indirect(self, command_buffer, buffer, offset) }
	}
}

/// Call `vkCmdSubpassShadingHUAWEI` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSubpassShadingHUAWEI` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSubpassShadingHUAWEI")]
#[doc = "\n\n[Khronos reference: `vkCmdSubpassShadingHUAWEI`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSubpassShadingHUAWEI.html)"]
pub unsafe fn cmd_subpass_shading_huawei(
	device: &Device,
	command_buffer: vk::CommandBuffer,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_subpass_shading_huawei
		.ok_or(CallError::MissingCommand("vkCmdSubpassShadingHUAWEI"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSubpassShadingHUAWEI` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSubpassShadingHUAWEI` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSubpassShadingHUAWEI")]
	#[doc = "\n\n[Khronos reference: `vkCmdSubpassShadingHUAWEI`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSubpassShadingHUAWEI.html)"]
	#[inline]
	pub unsafe fn cmd_subpass_shading_huawei(
		&self,
		command_buffer: vk::CommandBuffer,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_subpass_shading_huawei(self, command_buffer) }
	}
}

/// Call `vkCmdDrawClusterHUAWEI` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawClusterHUAWEI` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDrawClusterHUAWEI")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawClusterHUAWEI`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawClusterHUAWEI.html)"]
pub unsafe fn cmd_draw_cluster_huawei(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	group_count_x: u32,
	group_count_y: u32,
	group_count_z: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_cluster_huawei
		.ok_or(CallError::MissingCommand("vkCmdDrawClusterHUAWEI"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, group_count_x, group_count_y, group_count_z) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawClusterHUAWEI` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawClusterHUAWEI` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDrawClusterHUAWEI")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawClusterHUAWEI`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawClusterHUAWEI.html)"]
	#[inline]
	pub unsafe fn cmd_draw_cluster_huawei(
		&self,
		command_buffer: vk::CommandBuffer,
		group_count_x: u32,
		group_count_y: u32,
		group_count_z: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_draw_cluster_huawei(
				self,
				command_buffer,
				group_count_x,
				group_count_y,
				group_count_z,
			)
		}
	}
}

/// Call `vkCmdDrawClusterIndirectHUAWEI` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawClusterIndirectHUAWEI` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDrawClusterIndirectHUAWEI")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawClusterIndirectHUAWEI`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawClusterIndirectHUAWEI.html)"]
pub unsafe fn cmd_draw_cluster_indirect_huawei(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	buffer: vk::Buffer,
	offset: vk::DeviceSize,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_cluster_indirect_huawei
		.ok_or(CallError::MissingCommand("vkCmdDrawClusterIndirectHUAWEI"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, buffer, offset) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawClusterIndirectHUAWEI` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawClusterIndirectHUAWEI` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDrawClusterIndirectHUAWEI")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawClusterIndirectHUAWEI`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawClusterIndirectHUAWEI.html)"]
	#[inline]
	pub unsafe fn cmd_draw_cluster_indirect_huawei(
		&self,
		command_buffer: vk::CommandBuffer,
		buffer: vk::Buffer,
		offset: vk::DeviceSize,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_draw_cluster_indirect_huawei(self, command_buffer, buffer, offset) }
	}
}

/// Call `vkCmdUpdatePipelineIndirectBufferNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdUpdatePipelineIndirectBufferNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdUpdatePipelineIndirectBufferNV")]
#[doc = "\n\n[Khronos reference: `vkCmdUpdatePipelineIndirectBufferNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdUpdatePipelineIndirectBufferNV.html)"]
pub unsafe fn cmd_update_pipeline_indirect_buffer_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	pipeline_bind_point: vk::PipelineBindPoint,
	pipeline: vk::Pipeline,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_update_pipeline_indirect_buffer_nv
			.ok_or(CallError::MissingCommand(
				"vkCmdUpdatePipelineIndirectBufferNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, pipeline_bind_point, pipeline) };
	Ok(())
}

impl Device {
	/// Call `vkCmdUpdatePipelineIndirectBufferNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdUpdatePipelineIndirectBufferNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdUpdatePipelineIndirectBufferNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdUpdatePipelineIndirectBufferNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdUpdatePipelineIndirectBufferNV.html)"]
	#[inline]
	pub unsafe fn cmd_update_pipeline_indirect_buffer_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		pipeline_bind_point: vk::PipelineBindPoint,
		pipeline: vk::Pipeline,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_update_pipeline_indirect_buffer_nv(self, command_buffer, pipeline_bind_point, pipeline)
		}
	}
}

/// Call `vkCmdCopyBuffer` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyBuffer` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdCopyBuffer")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyBuffer`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyBuffer.html)"]
pub unsafe fn cmd_copy_buffer(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	src_buffer: vk::Buffer,
	dst_buffer: vk::Buffer,
	regions: &[vk::BufferCopy],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_buffer
		.ok_or(CallError::MissingCommand("vkCmdCopyBuffer"))?;
	let region_count =
		u32::try_from(regions.len()).map_err(|_| CallError::CountOverflow(regions.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			src_buffer,
			dst_buffer,
			region_count,
			regions.as_ptr(),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyBuffer` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyBuffer` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdCopyBuffer")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyBuffer`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyBuffer.html)"]
	#[inline]
	pub unsafe fn cmd_copy_buffer(
		&self,
		command_buffer: vk::CommandBuffer,
		src_buffer: vk::Buffer,
		dst_buffer: vk::Buffer,
		regions: &[vk::BufferCopy],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_buffer(self, command_buffer, src_buffer, dst_buffer, regions) }
	}
}

/// Call `vkCmdCopyImage` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyImage` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdCopyImage")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyImage`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyImage.html)"]
pub unsafe fn cmd_copy_image(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	src_image: vk::Image,
	src_image_layout: vk::ImageLayout,
	dst_image: vk::Image,
	dst_image_layout: vk::ImageLayout,
	regions: &[vk::ImageCopy],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_image
		.ok_or(CallError::MissingCommand("vkCmdCopyImage"))?;
	let region_count =
		u32::try_from(regions.len()).map_err(|_| CallError::CountOverflow(regions.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			src_image,
			src_image_layout,
			dst_image,
			dst_image_layout,
			region_count,
			regions.as_ptr(),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyImage` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyImage` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdCopyImage")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyImage`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyImage.html)"]
	#[inline]
	pub unsafe fn cmd_copy_image(
		&self,
		command_buffer: vk::CommandBuffer,
		src_image: vk::Image,
		src_image_layout: vk::ImageLayout,
		dst_image: vk::Image,
		dst_image_layout: vk::ImageLayout,
		regions: &[vk::ImageCopy],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_copy_image(
				self,
				command_buffer,
				src_image,
				src_image_layout,
				dst_image,
				dst_image_layout,
				regions,
			)
		}
	}
}

/// Call `vkCmdBlitImage` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBlitImage` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdBlitImage")]
#[doc = "\n\n[Khronos reference: `vkCmdBlitImage`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBlitImage.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_blit_image(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	src_image: vk::Image,
	src_image_layout: vk::ImageLayout,
	dst_image: vk::Image,
	dst_image_layout: vk::ImageLayout,
	regions: &[vk::ImageBlit],
	filter: vk::Filter,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_blit_image
		.ok_or(CallError::MissingCommand("vkCmdBlitImage"))?;
	let region_count =
		u32::try_from(regions.len()).map_err(|_| CallError::CountOverflow(regions.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			src_image,
			src_image_layout,
			dst_image,
			dst_image_layout,
			region_count,
			regions.as_ptr(),
			filter,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdBlitImage` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBlitImage` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdBlitImage")]
	#[doc = "\n\n[Khronos reference: `vkCmdBlitImage`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBlitImage.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_blit_image(
		&self,
		command_buffer: vk::CommandBuffer,
		src_image: vk::Image,
		src_image_layout: vk::ImageLayout,
		dst_image: vk::Image,
		dst_image_layout: vk::ImageLayout,
		regions: &[vk::ImageBlit],
		filter: vk::Filter,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_blit_image(
				self,
				command_buffer,
				src_image,
				src_image_layout,
				dst_image,
				dst_image_layout,
				regions,
				filter,
			)
		}
	}
}

/// Call `vkCmdCopyBufferToImage` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyBufferToImage` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdCopyBufferToImage")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyBufferToImage`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyBufferToImage.html)"]
pub unsafe fn cmd_copy_buffer_to_image(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	src_buffer: vk::Buffer,
	dst_image: vk::Image,
	dst_image_layout: vk::ImageLayout,
	regions: &[vk::BufferImageCopy],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_buffer_to_image
		.ok_or(CallError::MissingCommand("vkCmdCopyBufferToImage"))?;
	let region_count =
		u32::try_from(regions.len()).map_err(|_| CallError::CountOverflow(regions.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			src_buffer,
			dst_image,
			dst_image_layout,
			region_count,
			regions.as_ptr(),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyBufferToImage` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyBufferToImage` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdCopyBufferToImage")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyBufferToImage`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyBufferToImage.html)"]
	#[inline]
	pub unsafe fn cmd_copy_buffer_to_image(
		&self,
		command_buffer: vk::CommandBuffer,
		src_buffer: vk::Buffer,
		dst_image: vk::Image,
		dst_image_layout: vk::ImageLayout,
		regions: &[vk::BufferImageCopy],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_copy_buffer_to_image(
				self,
				command_buffer,
				src_buffer,
				dst_image,
				dst_image_layout,
				regions,
			)
		}
	}
}

/// Call `vkCmdCopyImageToBuffer` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyImageToBuffer` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdCopyImageToBuffer")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyImageToBuffer`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyImageToBuffer.html)"]
pub unsafe fn cmd_copy_image_to_buffer(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	src_image: vk::Image,
	src_image_layout: vk::ImageLayout,
	dst_buffer: vk::Buffer,
	regions: &[vk::BufferImageCopy],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_image_to_buffer
		.ok_or(CallError::MissingCommand("vkCmdCopyImageToBuffer"))?;
	let region_count =
		u32::try_from(regions.len()).map_err(|_| CallError::CountOverflow(regions.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			src_image,
			src_image_layout,
			dst_buffer,
			region_count,
			regions.as_ptr(),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyImageToBuffer` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyImageToBuffer` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdCopyImageToBuffer")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyImageToBuffer`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyImageToBuffer.html)"]
	#[inline]
	pub unsafe fn cmd_copy_image_to_buffer(
		&self,
		command_buffer: vk::CommandBuffer,
		src_image: vk::Image,
		src_image_layout: vk::ImageLayout,
		dst_buffer: vk::Buffer,
		regions: &[vk::BufferImageCopy],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_copy_image_to_buffer(
				self,
				command_buffer,
				src_image,
				src_image_layout,
				dst_buffer,
				regions,
			)
		}
	}
}

/// Call `vkCmdCopyMemoryIndirectNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyMemoryIndirectNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdCopyMemoryIndirectNV")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyMemoryIndirectNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyMemoryIndirectNV.html)"]
pub unsafe fn cmd_copy_memory_indirect_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	copy_buffer_address: vk::DeviceAddress,
	copy_count: u32,
	stride: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_memory_indirect_nv
		.ok_or(CallError::MissingCommand("vkCmdCopyMemoryIndirectNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, copy_buffer_address, copy_count, stride) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyMemoryIndirectNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyMemoryIndirectNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdCopyMemoryIndirectNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyMemoryIndirectNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyMemoryIndirectNV.html)"]
	#[inline]
	pub unsafe fn cmd_copy_memory_indirect_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		copy_buffer_address: vk::DeviceAddress,
		copy_count: u32,
		stride: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_copy_memory_indirect_nv(
				self,
				command_buffer,
				copy_buffer_address,
				copy_count,
				stride,
			)
		}
	}
}

/// Call `vkCmdCopyMemoryIndirectKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyMemoryIndirectKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdCopyMemoryIndirectKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyMemoryIndirectKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyMemoryIndirectKHR.html)"]
pub unsafe fn cmd_copy_memory_indirect_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_copy_memory_indirect_info: *const vk::CopyMemoryIndirectInfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_memory_indirect_khr
		.ok_or(CallError::MissingCommand("vkCmdCopyMemoryIndirectKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_copy_memory_indirect_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyMemoryIndirectKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyMemoryIndirectKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdCopyMemoryIndirectKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyMemoryIndirectKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyMemoryIndirectKHR.html)"]
	#[inline]
	pub unsafe fn cmd_copy_memory_indirect_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_copy_memory_indirect_info: *const vk::CopyMemoryIndirectInfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_memory_indirect_khr(self, command_buffer, p_copy_memory_indirect_info) }
	}
}

/// Call `vkCmdCopyMemoryToImageIndirectNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyMemoryToImageIndirectNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdCopyMemoryToImageIndirectNV")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyMemoryToImageIndirectNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyMemoryToImageIndirectNV.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_copy_memory_to_image_indirect_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	copy_buffer_address: vk::DeviceAddress,
	copy_count: u32,
	stride: u32,
	dst_image: vk::Image,
	dst_image_layout: vk::ImageLayout,
	p_image_subresources: *const vk::ImageSubresourceLayers,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_copy_memory_to_image_indirect_nv
			.ok_or(CallError::MissingCommand(
				"vkCmdCopyMemoryToImageIndirectNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			copy_buffer_address,
			copy_count,
			stride,
			dst_image,
			dst_image_layout,
			p_image_subresources,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyMemoryToImageIndirectNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyMemoryToImageIndirectNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdCopyMemoryToImageIndirectNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyMemoryToImageIndirectNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyMemoryToImageIndirectNV.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_copy_memory_to_image_indirect_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		copy_buffer_address: vk::DeviceAddress,
		copy_count: u32,
		stride: u32,
		dst_image: vk::Image,
		dst_image_layout: vk::ImageLayout,
		p_image_subresources: *const vk::ImageSubresourceLayers,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_copy_memory_to_image_indirect_nv(
				self,
				command_buffer,
				copy_buffer_address,
				copy_count,
				stride,
				dst_image,
				dst_image_layout,
				p_image_subresources,
			)
		}
	}
}

/// Call `vkCmdCopyMemoryToImageIndirectKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyMemoryToImageIndirectKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdCopyMemoryToImageIndirectKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyMemoryToImageIndirectKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyMemoryToImageIndirectKHR.html)"]
pub unsafe fn cmd_copy_memory_to_image_indirect_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_copy_memory_to_image_indirect_info: *const vk::CopyMemoryToImageIndirectInfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_copy_memory_to_image_indirect_khr
			.ok_or(CallError::MissingCommand(
				"vkCmdCopyMemoryToImageIndirectKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_copy_memory_to_image_indirect_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyMemoryToImageIndirectKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyMemoryToImageIndirectKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdCopyMemoryToImageIndirectKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyMemoryToImageIndirectKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyMemoryToImageIndirectKHR.html)"]
	#[inline]
	pub unsafe fn cmd_copy_memory_to_image_indirect_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_copy_memory_to_image_indirect_info: *const vk::CopyMemoryToImageIndirectInfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_copy_memory_to_image_indirect_khr(
				self,
				command_buffer,
				p_copy_memory_to_image_indirect_info,
			)
		}
	}
}

/// Call `vkCmdUpdateBuffer` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdUpdateBuffer` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Byte slices determine native byte counts. The caller must also satisfy the
/// command's data alignment, format, size-multiple and stride requirements;
/// a byte slice alone does not establish those properties.
#[doc(alias = "vkCmdUpdateBuffer")]
#[doc = "\n\n[Khronos reference: `vkCmdUpdateBuffer`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdUpdateBuffer.html)"]
pub unsafe fn cmd_update_buffer(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	dst_buffer: vk::Buffer,
	dst_offset: vk::DeviceSize,
	data: &[u8],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_update_buffer
		.ok_or(CallError::MissingCommand("vkCmdUpdateBuffer"))?;
	let data_size =
		vk::DeviceSize::try_from(data.len()).map_err(|_| CallError::CountOverflow(data.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			dst_buffer,
			dst_offset,
			data_size,
			data.as_ptr().cast(),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdUpdateBuffer` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdUpdateBuffer` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Byte slices determine native byte counts. The caller must also satisfy the
	/// command's data alignment, format, size-multiple and stride requirements;
	/// a byte slice alone does not establish those properties.
	#[doc(alias = "vkCmdUpdateBuffer")]
	#[doc = "\n\n[Khronos reference: `vkCmdUpdateBuffer`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdUpdateBuffer.html)"]
	#[inline]
	pub unsafe fn cmd_update_buffer(
		&self,
		command_buffer: vk::CommandBuffer,
		dst_buffer: vk::Buffer,
		dst_offset: vk::DeviceSize,
		data: &[u8],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_update_buffer(self, command_buffer, dst_buffer, dst_offset, data) }
	}
}

/// Call `vkCmdClearColorImage` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdClearColorImage` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdClearColorImage")]
#[doc = "\n\n[Khronos reference: `vkCmdClearColorImage`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdClearColorImage.html)"]
pub unsafe fn cmd_clear_color_image(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	image: vk::Image,
	image_layout: vk::ImageLayout,
	color: &vk::ClearColorValue,
	ranges: &[vk::ImageSubresourceRange],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_clear_color_image
		.ok_or(CallError::MissingCommand("vkCmdClearColorImage"))?;
	let range_count =
		u32::try_from(ranges.len()).map_err(|_| CallError::CountOverflow(ranges.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			image,
			image_layout,
			color,
			range_count,
			ranges.as_ptr(),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdClearColorImage` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdClearColorImage` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdClearColorImage")]
	#[doc = "\n\n[Khronos reference: `vkCmdClearColorImage`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdClearColorImage.html)"]
	#[inline]
	pub unsafe fn cmd_clear_color_image(
		&self,
		command_buffer: vk::CommandBuffer,
		image: vk::Image,
		image_layout: vk::ImageLayout,
		color: &vk::ClearColorValue,
		ranges: &[vk::ImageSubresourceRange],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_clear_color_image(self, command_buffer, image, image_layout, color, ranges) }
	}
}

/// Call `vkCmdClearDepthStencilImage` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdClearDepthStencilImage` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdClearDepthStencilImage")]
#[doc = "\n\n[Khronos reference: `vkCmdClearDepthStencilImage`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdClearDepthStencilImage.html)"]
pub unsafe fn cmd_clear_depth_stencil_image(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	image: vk::Image,
	image_layout: vk::ImageLayout,
	depth_stencil: &vk::ClearDepthStencilValue,
	ranges: &[vk::ImageSubresourceRange],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_clear_depth_stencil_image
		.ok_or(CallError::MissingCommand("vkCmdClearDepthStencilImage"))?;
	let range_count =
		u32::try_from(ranges.len()).map_err(|_| CallError::CountOverflow(ranges.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			image,
			image_layout,
			depth_stencil,
			range_count,
			ranges.as_ptr(),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdClearDepthStencilImage` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdClearDepthStencilImage` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdClearDepthStencilImage")]
	#[doc = "\n\n[Khronos reference: `vkCmdClearDepthStencilImage`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdClearDepthStencilImage.html)"]
	#[inline]
	pub unsafe fn cmd_clear_depth_stencil_image(
		&self,
		command_buffer: vk::CommandBuffer,
		image: vk::Image,
		image_layout: vk::ImageLayout,
		depth_stencil: &vk::ClearDepthStencilValue,
		ranges: &[vk::ImageSubresourceRange],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_clear_depth_stencil_image(
				self,
				command_buffer,
				image,
				image_layout,
				depth_stencil,
				ranges,
			)
		}
	}
}

/// Call `vkCmdClearAttachments` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdClearAttachments` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdClearAttachments")]
#[doc = "\n\n[Khronos reference: `vkCmdClearAttachments`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdClearAttachments.html)"]
pub unsafe fn cmd_clear_attachments(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	attachments: &[vk::ClearAttachment],
	rects: &[vk::ClearRect],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_clear_attachments
		.ok_or(CallError::MissingCommand("vkCmdClearAttachments"))?;
	let attachment_count =
		u32::try_from(attachments.len()).map_err(|_| CallError::CountOverflow(attachments.len()))?;
	let rect_count = u32::try_from(rects.len()).map_err(|_| CallError::CountOverflow(rects.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			attachment_count,
			attachments.as_ptr(),
			rect_count,
			rects.as_ptr(),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdClearAttachments` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdClearAttachments` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdClearAttachments")]
	#[doc = "\n\n[Khronos reference: `vkCmdClearAttachments`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdClearAttachments.html)"]
	#[inline]
	pub unsafe fn cmd_clear_attachments(
		&self,
		command_buffer: vk::CommandBuffer,
		attachments: &[vk::ClearAttachment],
		rects: &[vk::ClearRect],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_clear_attachments(self, command_buffer, attachments, rects) }
	}
}

/// Call `vkCmdResolveImage` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdResolveImage` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdResolveImage")]
#[doc = "\n\n[Khronos reference: `vkCmdResolveImage`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdResolveImage.html)"]
pub unsafe fn cmd_resolve_image(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	src_image: vk::Image,
	src_image_layout: vk::ImageLayout,
	dst_image: vk::Image,
	dst_image_layout: vk::ImageLayout,
	regions: &[vk::ImageResolve],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_resolve_image
		.ok_or(CallError::MissingCommand("vkCmdResolveImage"))?;
	let region_count =
		u32::try_from(regions.len()).map_err(|_| CallError::CountOverflow(regions.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			src_image,
			src_image_layout,
			dst_image,
			dst_image_layout,
			region_count,
			regions.as_ptr(),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdResolveImage` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdResolveImage` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdResolveImage")]
	#[doc = "\n\n[Khronos reference: `vkCmdResolveImage`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdResolveImage.html)"]
	#[inline]
	pub unsafe fn cmd_resolve_image(
		&self,
		command_buffer: vk::CommandBuffer,
		src_image: vk::Image,
		src_image_layout: vk::ImageLayout,
		dst_image: vk::Image,
		dst_image_layout: vk::ImageLayout,
		regions: &[vk::ImageResolve],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_resolve_image(
				self,
				command_buffer,
				src_image,
				src_image_layout,
				dst_image,
				dst_image_layout,
				regions,
			)
		}
	}
}

/// Call `vkCmdSetEvent` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetEvent` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdSetEvent")]
#[doc = "\n\n[Khronos reference: `vkCmdSetEvent`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetEvent.html)"]
pub unsafe fn cmd_set_event(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	event: vk::Event,
	stage_mask: vk::PipelineStageFlags,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_event
		.ok_or(CallError::MissingCommand("vkCmdSetEvent"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, event, stage_mask) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetEvent` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetEvent` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdSetEvent")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetEvent`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetEvent.html)"]
	#[inline]
	pub unsafe fn cmd_set_event(
		&self,
		command_buffer: vk::CommandBuffer,
		event: vk::Event,
		stage_mask: vk::PipelineStageFlags,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_event(self, command_buffer, event, stage_mask) }
	}
}

/// Call `vkCmdResetEvent` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdResetEvent` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdResetEvent")]
#[doc = "\n\n[Khronos reference: `vkCmdResetEvent`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdResetEvent.html)"]
pub unsafe fn cmd_reset_event(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	event: vk::Event,
	stage_mask: vk::PipelineStageFlags,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_reset_event
		.ok_or(CallError::MissingCommand("vkCmdResetEvent"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, event, stage_mask) };
	Ok(())
}

impl Device {
	/// Call `vkCmdResetEvent` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdResetEvent` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdResetEvent")]
	#[doc = "\n\n[Khronos reference: `vkCmdResetEvent`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdResetEvent.html)"]
	#[inline]
	pub unsafe fn cmd_reset_event(
		&self,
		command_buffer: vk::CommandBuffer,
		event: vk::Event,
		stage_mask: vk::PipelineStageFlags,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_reset_event(self, command_buffer, event, stage_mask) }
	}
}

/// Call `vkCmdWaitEvents` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdWaitEvents` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdWaitEvents")]
#[doc = "\n\n[Khronos reference: `vkCmdWaitEvents`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWaitEvents.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_wait_events(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	events: &[vk::Event],
	src_stage_mask: vk::PipelineStageFlags,
	dst_stage_mask: vk::PipelineStageFlags,
	memory_barriers: &[vk::MemoryBarrier<'_>],
	buffer_memory_barriers: &[vk::BufferMemoryBarrier<'_>],
	image_memory_barriers: &[vk::ImageMemoryBarrier<'_>],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_wait_events
		.ok_or(CallError::MissingCommand("vkCmdWaitEvents"))?;
	let event_count =
		u32::try_from(events.len()).map_err(|_| CallError::CountOverflow(events.len()))?;
	let memory_barrier_count = u32::try_from(memory_barriers.len())
		.map_err(|_| CallError::CountOverflow(memory_barriers.len()))?;
	let buffer_memory_barrier_count = u32::try_from(buffer_memory_barriers.len())
		.map_err(|_| CallError::CountOverflow(buffer_memory_barriers.len()))?;
	let image_memory_barrier_count = u32::try_from(image_memory_barriers.len())
		.map_err(|_| CallError::CountOverflow(image_memory_barriers.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			event_count,
			events.as_ptr(),
			src_stage_mask,
			dst_stage_mask,
			memory_barrier_count,
			memory_barriers.as_ptr(),
			buffer_memory_barrier_count,
			buffer_memory_barriers.as_ptr(),
			image_memory_barrier_count,
			image_memory_barriers.as_ptr(),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdWaitEvents` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdWaitEvents` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdWaitEvents")]
	#[doc = "\n\n[Khronos reference: `vkCmdWaitEvents`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWaitEvents.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_wait_events(
		&self,
		command_buffer: vk::CommandBuffer,
		events: &[vk::Event],
		src_stage_mask: vk::PipelineStageFlags,
		dst_stage_mask: vk::PipelineStageFlags,
		memory_barriers: &[vk::MemoryBarrier<'_>],
		buffer_memory_barriers: &[vk::BufferMemoryBarrier<'_>],
		image_memory_barriers: &[vk::ImageMemoryBarrier<'_>],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_wait_events(
				self,
				command_buffer,
				events,
				src_stage_mask,
				dst_stage_mask,
				memory_barriers,
				buffer_memory_barriers,
				image_memory_barriers,
			)
		}
	}
}

/// Call `vkCmdPipelineBarrier` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdPipelineBarrier` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdPipelineBarrier")]
#[doc = "\n\n[Khronos reference: `vkCmdPipelineBarrier`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPipelineBarrier.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_pipeline_barrier(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	src_stage_mask: vk::PipelineStageFlags,
	dst_stage_mask: vk::PipelineStageFlags,
	dependency_flags: vk::DependencyFlags,
	memory_barriers: &[vk::MemoryBarrier<'_>],
	buffer_memory_barriers: &[vk::BufferMemoryBarrier<'_>],
	image_memory_barriers: &[vk::ImageMemoryBarrier<'_>],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_pipeline_barrier
		.ok_or(CallError::MissingCommand("vkCmdPipelineBarrier"))?;
	let memory_barrier_count = u32::try_from(memory_barriers.len())
		.map_err(|_| CallError::CountOverflow(memory_barriers.len()))?;
	let buffer_memory_barrier_count = u32::try_from(buffer_memory_barriers.len())
		.map_err(|_| CallError::CountOverflow(buffer_memory_barriers.len()))?;
	let image_memory_barrier_count = u32::try_from(image_memory_barriers.len())
		.map_err(|_| CallError::CountOverflow(image_memory_barriers.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			src_stage_mask,
			dst_stage_mask,
			dependency_flags,
			memory_barrier_count,
			memory_barriers.as_ptr(),
			buffer_memory_barrier_count,
			buffer_memory_barriers.as_ptr(),
			image_memory_barrier_count,
			image_memory_barriers.as_ptr(),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdPipelineBarrier` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdPipelineBarrier` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdPipelineBarrier")]
	#[doc = "\n\n[Khronos reference: `vkCmdPipelineBarrier`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPipelineBarrier.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_pipeline_barrier(
		&self,
		command_buffer: vk::CommandBuffer,
		src_stage_mask: vk::PipelineStageFlags,
		dst_stage_mask: vk::PipelineStageFlags,
		dependency_flags: vk::DependencyFlags,
		memory_barriers: &[vk::MemoryBarrier<'_>],
		buffer_memory_barriers: &[vk::BufferMemoryBarrier<'_>],
		image_memory_barriers: &[vk::ImageMemoryBarrier<'_>],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_pipeline_barrier(
				self,
				command_buffer,
				src_stage_mask,
				dst_stage_mask,
				dependency_flags,
				memory_barriers,
				buffer_memory_barriers,
				image_memory_barriers,
			)
		}
	}
}

/// Call `vkCmdBeginQuery` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBeginQuery` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdBeginQuery")]
#[doc = "\n\n[Khronos reference: `vkCmdBeginQuery`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginQuery.html)"]
pub unsafe fn cmd_begin_query(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	query_pool: vk::QueryPool,
	query: u32,
	flags: vk::QueryControlFlags,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_begin_query
		.ok_or(CallError::MissingCommand("vkCmdBeginQuery"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, query_pool, query, flags) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBeginQuery` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBeginQuery` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdBeginQuery")]
	#[doc = "\n\n[Khronos reference: `vkCmdBeginQuery`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginQuery.html)"]
	#[inline]
	pub unsafe fn cmd_begin_query(
		&self,
		command_buffer: vk::CommandBuffer,
		query_pool: vk::QueryPool,
		query: u32,
		flags: vk::QueryControlFlags,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_begin_query(self, command_buffer, query_pool, query, flags) }
	}
}

/// Call `vkCmdEndQuery` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdEndQuery` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdEndQuery")]
#[doc = "\n\n[Khronos reference: `vkCmdEndQuery`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndQuery.html)"]
pub unsafe fn cmd_end_query(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	query_pool: vk::QueryPool,
	query: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_end_query
		.ok_or(CallError::MissingCommand("vkCmdEndQuery"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, query_pool, query) };
	Ok(())
}

impl Device {
	/// Call `vkCmdEndQuery` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdEndQuery` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdEndQuery")]
	#[doc = "\n\n[Khronos reference: `vkCmdEndQuery`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndQuery.html)"]
	#[inline]
	pub unsafe fn cmd_end_query(
		&self,
		command_buffer: vk::CommandBuffer,
		query_pool: vk::QueryPool,
		query: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_end_query(self, command_buffer, query_pool, query) }
	}
}

/// Call `vkCmdBeginConditionalRenderingEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBeginConditionalRenderingEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBeginConditionalRenderingEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdBeginConditionalRenderingEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginConditionalRenderingEXT.html)"]
pub unsafe fn cmd_begin_conditional_rendering_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_conditional_rendering_begin: *const vk::ConditionalRenderingBeginInfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_begin_conditional_rendering_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdBeginConditionalRenderingEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_conditional_rendering_begin) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBeginConditionalRenderingEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBeginConditionalRenderingEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBeginConditionalRenderingEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdBeginConditionalRenderingEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginConditionalRenderingEXT.html)"]
	#[inline]
	pub unsafe fn cmd_begin_conditional_rendering_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_conditional_rendering_begin: *const vk::ConditionalRenderingBeginInfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_begin_conditional_rendering_ext(self, command_buffer, p_conditional_rendering_begin)
		}
	}
}

/// Call `vkCmdEndConditionalRenderingEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdEndConditionalRenderingEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdEndConditionalRenderingEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdEndConditionalRenderingEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndConditionalRenderingEXT.html)"]
pub unsafe fn cmd_end_conditional_rendering_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_end_conditional_rendering_ext
		.ok_or(CallError::MissingCommand("vkCmdEndConditionalRenderingEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer) };
	Ok(())
}

impl Device {
	/// Call `vkCmdEndConditionalRenderingEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdEndConditionalRenderingEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdEndConditionalRenderingEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdEndConditionalRenderingEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndConditionalRenderingEXT.html)"]
	#[inline]
	pub unsafe fn cmd_end_conditional_rendering_ext(
		&self,
		command_buffer: vk::CommandBuffer,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_end_conditional_rendering_ext(self, command_buffer) }
	}
}

/// Call `vkCmdBeginCustomResolveEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBeginCustomResolveEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBeginCustomResolveEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdBeginCustomResolveEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginCustomResolveEXT.html)"]
pub unsafe fn cmd_begin_custom_resolve_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_begin_custom_resolve_info: *const vk::BeginCustomResolveInfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_begin_custom_resolve_ext
		.ok_or(CallError::MissingCommand("vkCmdBeginCustomResolveEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_begin_custom_resolve_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBeginCustomResolveEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBeginCustomResolveEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBeginCustomResolveEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdBeginCustomResolveEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginCustomResolveEXT.html)"]
	#[inline]
	pub unsafe fn cmd_begin_custom_resolve_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_begin_custom_resolve_info: *const vk::BeginCustomResolveInfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_begin_custom_resolve_ext(self, command_buffer, p_begin_custom_resolve_info) }
	}
}

/// Call `vkCmdResetQueryPool` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdResetQueryPool` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdResetQueryPool")]
#[doc = "\n\n[Khronos reference: `vkCmdResetQueryPool`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdResetQueryPool.html)"]
pub unsafe fn cmd_reset_query_pool(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	query_pool: vk::QueryPool,
	first_query: u32,
	query_count: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_reset_query_pool
		.ok_or(CallError::MissingCommand("vkCmdResetQueryPool"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, query_pool, first_query, query_count) };
	Ok(())
}

impl Device {
	/// Call `vkCmdResetQueryPool` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdResetQueryPool` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdResetQueryPool")]
	#[doc = "\n\n[Khronos reference: `vkCmdResetQueryPool`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdResetQueryPool.html)"]
	#[inline]
	pub unsafe fn cmd_reset_query_pool(
		&self,
		command_buffer: vk::CommandBuffer,
		query_pool: vk::QueryPool,
		first_query: u32,
		query_count: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_reset_query_pool(self, command_buffer, query_pool, first_query, query_count) }
	}
}

/// Call `vkCmdWriteTimestamp` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdWriteTimestamp` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdWriteTimestamp")]
#[doc = "\n\n[Khronos reference: `vkCmdWriteTimestamp`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWriteTimestamp.html)"]
pub unsafe fn cmd_write_timestamp(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	pipeline_stage: vk::PipelineStageFlagBits,
	query_pool: vk::QueryPool,
	query: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_write_timestamp
		.ok_or(CallError::MissingCommand("vkCmdWriteTimestamp"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, pipeline_stage, query_pool, query) };
	Ok(())
}

impl Device {
	/// Call `vkCmdWriteTimestamp` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdWriteTimestamp` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdWriteTimestamp")]
	#[doc = "\n\n[Khronos reference: `vkCmdWriteTimestamp`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWriteTimestamp.html)"]
	#[inline]
	pub unsafe fn cmd_write_timestamp(
		&self,
		command_buffer: vk::CommandBuffer,
		pipeline_stage: vk::PipelineStageFlagBits,
		query_pool: vk::QueryPool,
		query: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_write_timestamp(self, command_buffer, pipeline_stage, query_pool, query) }
	}
}

/// Call `vkCmdCopyQueryPoolResults` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyQueryPoolResults` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdCopyQueryPoolResults")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyQueryPoolResults`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyQueryPoolResults.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_copy_query_pool_results(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	query_pool: vk::QueryPool,
	first_query: u32,
	query_count: u32,
	dst_buffer: vk::Buffer,
	dst_offset: vk::DeviceSize,
	stride: vk::DeviceSize,
	flags: vk::QueryResultFlags,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_query_pool_results
		.ok_or(CallError::MissingCommand("vkCmdCopyQueryPoolResults"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			query_pool,
			first_query,
			query_count,
			dst_buffer,
			dst_offset,
			stride,
			flags,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyQueryPoolResults` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyQueryPoolResults` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdCopyQueryPoolResults")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyQueryPoolResults`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyQueryPoolResults.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_copy_query_pool_results(
		&self,
		command_buffer: vk::CommandBuffer,
		query_pool: vk::QueryPool,
		first_query: u32,
		query_count: u32,
		dst_buffer: vk::Buffer,
		dst_offset: vk::DeviceSize,
		stride: vk::DeviceSize,
		flags: vk::QueryResultFlags,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_copy_query_pool_results(
				self,
				command_buffer,
				query_pool,
				first_query,
				query_count,
				dst_buffer,
				dst_offset,
				stride,
				flags,
			)
		}
	}
}

/// Call `vkCmdPushConstants` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdPushConstants` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Byte slices determine native byte counts. The caller must also satisfy the
/// command's data alignment, format, size-multiple and stride requirements;
/// a byte slice alone does not establish those properties.
#[doc(alias = "vkCmdPushConstants")]
#[doc = "\n\n[Khronos reference: `vkCmdPushConstants`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushConstants.html)"]
pub unsafe fn cmd_push_constants(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	layout: vk::PipelineLayout,
	stage_flags: vk::ShaderStageFlags,
	offset: u32,
	values: &[u8],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_push_constants
		.ok_or(CallError::MissingCommand("vkCmdPushConstants"))?;
	let size = u32::try_from(values.len()).map_err(|_| CallError::CountOverflow(values.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			layout,
			stage_flags,
			offset,
			size,
			values.as_ptr().cast(),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdPushConstants` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdPushConstants` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Byte slices determine native byte counts. The caller must also satisfy the
	/// command's data alignment, format, size-multiple and stride requirements;
	/// a byte slice alone does not establish those properties.
	#[doc(alias = "vkCmdPushConstants")]
	#[doc = "\n\n[Khronos reference: `vkCmdPushConstants`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushConstants.html)"]
	#[inline]
	pub unsafe fn cmd_push_constants(
		&self,
		command_buffer: vk::CommandBuffer,
		layout: vk::PipelineLayout,
		stage_flags: vk::ShaderStageFlags,
		offset: u32,
		values: &[u8],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_push_constants(self, command_buffer, layout, stage_flags, offset, values) }
	}
}

/// Call `vkCmdBeginRenderPass` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBeginRenderPass` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdBeginRenderPass")]
#[doc = "\n\n[Khronos reference: `vkCmdBeginRenderPass`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginRenderPass.html)"]
pub unsafe fn cmd_begin_render_pass(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	render_pass_begin: &vk::RenderPassBeginInfo<'_>,
	contents: vk::SubpassContents,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_begin_render_pass
		.ok_or(CallError::MissingCommand("vkCmdBeginRenderPass"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, render_pass_begin, contents) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBeginRenderPass` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBeginRenderPass` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdBeginRenderPass")]
	#[doc = "\n\n[Khronos reference: `vkCmdBeginRenderPass`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginRenderPass.html)"]
	#[inline]
	pub unsafe fn cmd_begin_render_pass(
		&self,
		command_buffer: vk::CommandBuffer,
		render_pass_begin: &vk::RenderPassBeginInfo<'_>,
		contents: vk::SubpassContents,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_begin_render_pass(self, command_buffer, render_pass_begin, contents) }
	}
}

/// Call `vkCmdNextSubpass` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdNextSubpass` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdNextSubpass")]
#[doc = "\n\n[Khronos reference: `vkCmdNextSubpass`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdNextSubpass.html)"]
pub unsafe fn cmd_next_subpass(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	contents: vk::SubpassContents,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_next_subpass
		.ok_or(CallError::MissingCommand("vkCmdNextSubpass"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, contents) };
	Ok(())
}

impl Device {
	/// Call `vkCmdNextSubpass` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdNextSubpass` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdNextSubpass")]
	#[doc = "\n\n[Khronos reference: `vkCmdNextSubpass`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdNextSubpass.html)"]
	#[inline]
	pub unsafe fn cmd_next_subpass(
		&self,
		command_buffer: vk::CommandBuffer,
		contents: vk::SubpassContents,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_next_subpass(self, command_buffer, contents) }
	}
}

/// Call `vkCmdEndRenderPass` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdEndRenderPass` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdEndRenderPass")]
#[doc = "\n\n[Khronos reference: `vkCmdEndRenderPass`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndRenderPass.html)"]
pub unsafe fn cmd_end_render_pass(
	device: &Device,
	command_buffer: vk::CommandBuffer,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_end_render_pass
		.ok_or(CallError::MissingCommand("vkCmdEndRenderPass"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer) };
	Ok(())
}

impl Device {
	/// Call `vkCmdEndRenderPass` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdEndRenderPass` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdEndRenderPass")]
	#[doc = "\n\n[Khronos reference: `vkCmdEndRenderPass`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndRenderPass.html)"]
	#[inline]
	pub unsafe fn cmd_end_render_pass(
		&self,
		command_buffer: vk::CommandBuffer,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_end_render_pass(self, command_buffer) }
	}
}

/// Call `vkCmdExecuteCommands` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdExecuteCommands` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdExecuteCommands")]
#[doc = "\n\n[Khronos reference: `vkCmdExecuteCommands`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdExecuteCommands.html)"]
pub unsafe fn cmd_execute_commands(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	command_buffers: &[vk::CommandBuffer],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_execute_commands
		.ok_or(CallError::MissingCommand("vkCmdExecuteCommands"))?;
	let command_buffer_count = u32::try_from(command_buffers.len())
		.map_err(|_| CallError::CountOverflow(command_buffers.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			command_buffer_count,
			command_buffers.as_ptr(),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdExecuteCommands` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdExecuteCommands` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdExecuteCommands")]
	#[doc = "\n\n[Khronos reference: `vkCmdExecuteCommands`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdExecuteCommands.html)"]
	#[inline]
	pub unsafe fn cmd_execute_commands(
		&self,
		command_buffer: vk::CommandBuffer,
		command_buffers: &[vk::CommandBuffer],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_execute_commands(self, command_buffer, command_buffers) }
	}
}

#[cfg(feature = "platform-android")]
/// Call `vkCreateAndroidSurfaceKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateAndroidSurfaceKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateAndroidSurfaceKHR")]
#[doc = "\n\n[Khronos reference: `vkCreateAndroidSurfaceKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateAndroidSurfaceKHR.html)"]
pub unsafe fn create_android_surface_khr(
	instance: &Instance,
	p_create_info: *const vk::AndroidSurfaceCreateInfoKHR<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_surface: *mut vk::SurfaceKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.create_android_surface_khr
		.ok_or(CallError::MissingCommand("vkCreateAndroidSurfaceKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), p_create_info, p_allocator, p_surface) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-android")]
impl Instance {
	/// Call `vkCreateAndroidSurfaceKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateAndroidSurfaceKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateAndroidSurfaceKHR")]
	#[doc = "\n\n[Khronos reference: `vkCreateAndroidSurfaceKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateAndroidSurfaceKHR.html)"]
	#[inline]
	pub unsafe fn create_android_surface_khr(
		&self,
		p_create_info: *const vk::AndroidSurfaceCreateInfoKHR<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_surface: *mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_android_surface_khr(self, p_create_info, p_allocator, p_surface) }
	}
}

#[cfg(feature = "platform-ohos")]
/// Call `vkCreateSurfaceOHOS` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateSurfaceOHOS` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateSurfaceOHOS")]
#[doc = "\n\n[Khronos reference: `vkCreateSurfaceOHOS`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateSurfaceOHOS.html)"]
pub unsafe fn create_surface_ohos(
	instance: &Instance,
	p_create_info: *const vk::SurfaceCreateInfoOHOS<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_surface: *mut vk::SurfaceKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.create_surface_ohos
		.ok_or(CallError::MissingCommand("vkCreateSurfaceOHOS"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), p_create_info, p_allocator, p_surface) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-ohos")]
impl Instance {
	/// Call `vkCreateSurfaceOHOS` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateSurfaceOHOS` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateSurfaceOHOS")]
	#[doc = "\n\n[Khronos reference: `vkCreateSurfaceOHOS`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateSurfaceOHOS.html)"]
	#[inline]
	pub unsafe fn create_surface_ohos(
		&self,
		p_create_info: *const vk::SurfaceCreateInfoOHOS<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_surface: *mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_surface_ohos(self, p_create_info, p_allocator, p_surface) }
	}
}

/// Call `vkGetPhysicalDeviceDisplayPropertiesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceDisplayPropertiesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceDisplayPropertiesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceDisplayPropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceDisplayPropertiesKHR.html)"]
pub unsafe fn get_physical_device_display_properties_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_property_count: *mut u32,
	p_properties: *mut vk::DisplayPropertiesKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_display_properties_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceDisplayPropertiesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, p_property_count, p_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceDisplayPropertiesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceDisplayPropertiesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceDisplayPropertiesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceDisplayPropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceDisplayPropertiesKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_display_properties_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		p_property_count: *mut u32,
		p_properties: *mut vk::DisplayPropertiesKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_display_properties_khr(
				self,
				physical_device,
				p_property_count,
				p_properties,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceDisplayPlanePropertiesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceDisplayPlanePropertiesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceDisplayPlanePropertiesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceDisplayPlanePropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html)"]
pub unsafe fn get_physical_device_display_plane_properties_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_property_count: *mut u32,
	p_properties: *mut vk::DisplayPlanePropertiesKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_display_plane_properties_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceDisplayPlanePropertiesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, p_property_count, p_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceDisplayPlanePropertiesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceDisplayPlanePropertiesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceDisplayPlanePropertiesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceDisplayPlanePropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_display_plane_properties_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		p_property_count: *mut u32,
		p_properties: *mut vk::DisplayPlanePropertiesKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_display_plane_properties_khr(
				self,
				physical_device,
				p_property_count,
				p_properties,
			)
		}
	}
}

/// Call `vkGetDisplayPlaneSupportedDisplaysKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDisplayPlaneSupportedDisplaysKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDisplayPlaneSupportedDisplaysKHR")]
#[doc = "\n\n[Khronos reference: `vkGetDisplayPlaneSupportedDisplaysKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDisplayPlaneSupportedDisplaysKHR.html)"]
pub unsafe fn get_display_plane_supported_displays_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	plane_index: u32,
	p_display_count: *mut u32,
	p_displays: *mut vk::DisplayKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_display_plane_supported_displays_khr
		.ok_or(CallError::MissingCommand(
			"vkGetDisplayPlaneSupportedDisplaysKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, plane_index, p_display_count, p_displays) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetDisplayPlaneSupportedDisplaysKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDisplayPlaneSupportedDisplaysKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDisplayPlaneSupportedDisplaysKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetDisplayPlaneSupportedDisplaysKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDisplayPlaneSupportedDisplaysKHR.html)"]
	#[inline]
	pub unsafe fn get_display_plane_supported_displays_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		plane_index: u32,
		p_display_count: *mut u32,
		p_displays: *mut vk::DisplayKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_display_plane_supported_displays_khr(
				self,
				physical_device,
				plane_index,
				p_display_count,
				p_displays,
			)
		}
	}
}

/// Call `vkGetDisplayModePropertiesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDisplayModePropertiesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDisplayModePropertiesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetDisplayModePropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDisplayModePropertiesKHR.html)"]
pub unsafe fn get_display_mode_properties_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	display: vk::DisplayKHR,
	p_property_count: *mut u32,
	p_properties: *mut vk::DisplayModePropertiesKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_display_mode_properties_khr
		.ok_or(CallError::MissingCommand("vkGetDisplayModePropertiesKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, display, p_property_count, p_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetDisplayModePropertiesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDisplayModePropertiesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDisplayModePropertiesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetDisplayModePropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDisplayModePropertiesKHR.html)"]
	#[inline]
	pub unsafe fn get_display_mode_properties_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		display: vk::DisplayKHR,
		p_property_count: *mut u32,
		p_properties: *mut vk::DisplayModePropertiesKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_display_mode_properties_khr(
				self,
				physical_device,
				display,
				p_property_count,
				p_properties,
			)
		}
	}
}

/// Call `vkCreateDisplayModeKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateDisplayModeKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateDisplayModeKHR")]
#[doc = "\n\n[Khronos reference: `vkCreateDisplayModeKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDisplayModeKHR.html)"]
pub unsafe fn create_display_mode_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	display: vk::DisplayKHR,
	p_create_info: *const vk::DisplayModeCreateInfoKHR<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_mode: *mut vk::DisplayModeKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.create_display_mode_khr
		.ok_or(CallError::MissingCommand("vkCreateDisplayModeKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result =
		unsafe { __vk_function(physical_device, display, p_create_info, p_allocator, p_mode) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkCreateDisplayModeKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateDisplayModeKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateDisplayModeKHR")]
	#[doc = "\n\n[Khronos reference: `vkCreateDisplayModeKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDisplayModeKHR.html)"]
	#[inline]
	pub unsafe fn create_display_mode_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		display: vk::DisplayKHR,
		p_create_info: *const vk::DisplayModeCreateInfoKHR<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_mode: *mut vk::DisplayModeKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			create_display_mode_khr(
				self,
				physical_device,
				display,
				p_create_info,
				p_allocator,
				p_mode,
			)
		}
	}
}

/// Call `vkGetDisplayPlaneCapabilitiesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDisplayPlaneCapabilitiesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDisplayPlaneCapabilitiesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetDisplayPlaneCapabilitiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDisplayPlaneCapabilitiesKHR.html)"]
pub unsafe fn get_display_plane_capabilities_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	mode: vk::DisplayModeKHR,
	plane_index: u32,
	p_capabilities: *mut vk::DisplayPlaneCapabilitiesKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		instance
			.fp()
			.get_display_plane_capabilities_khr
			.ok_or(CallError::MissingCommand(
				"vkGetDisplayPlaneCapabilitiesKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, mode, plane_index, p_capabilities) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetDisplayPlaneCapabilitiesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDisplayPlaneCapabilitiesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDisplayPlaneCapabilitiesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetDisplayPlaneCapabilitiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDisplayPlaneCapabilitiesKHR.html)"]
	#[inline]
	pub unsafe fn get_display_plane_capabilities_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		mode: vk::DisplayModeKHR,
		plane_index: u32,
		p_capabilities: *mut vk::DisplayPlaneCapabilitiesKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_display_plane_capabilities_khr(self, physical_device, mode, plane_index, p_capabilities)
		}
	}
}

/// Call `vkCreateDisplayPlaneSurfaceKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateDisplayPlaneSurfaceKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateDisplayPlaneSurfaceKHR")]
#[doc = "\n\n[Khronos reference: `vkCreateDisplayPlaneSurfaceKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDisplayPlaneSurfaceKHR.html)"]
pub unsafe fn create_display_plane_surface_khr(
	instance: &Instance,
	p_create_info: *const vk::DisplaySurfaceCreateInfoKHR<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_surface: *mut vk::SurfaceKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.create_display_plane_surface_khr
		.ok_or(CallError::MissingCommand("vkCreateDisplayPlaneSurfaceKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), p_create_info, p_allocator, p_surface) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkCreateDisplayPlaneSurfaceKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateDisplayPlaneSurfaceKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateDisplayPlaneSurfaceKHR")]
	#[doc = "\n\n[Khronos reference: `vkCreateDisplayPlaneSurfaceKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDisplayPlaneSurfaceKHR.html)"]
	#[inline]
	pub unsafe fn create_display_plane_surface_khr(
		&self,
		p_create_info: *const vk::DisplaySurfaceCreateInfoKHR<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_surface: *mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_display_plane_surface_khr(self, p_create_info, p_allocator, p_surface) }
	}
}

/// Call `vkCreateSharedSwapchainsKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateSharedSwapchainsKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateSharedSwapchainsKHR")]
#[doc = "\n\n[Khronos reference: `vkCreateSharedSwapchainsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateSharedSwapchainsKHR.html)"]
pub unsafe fn create_shared_swapchains_khr(
	device: &Device,
	swapchain_count: u32,
	p_create_infos: *const vk::SwapchainCreateInfoKHR<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_swapchains: *mut vk::SwapchainKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_shared_swapchains_khr
		.ok_or(CallError::MissingCommand("vkCreateSharedSwapchainsKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			swapchain_count,
			p_create_infos,
			p_allocator,
			p_swapchains,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateSharedSwapchainsKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateSharedSwapchainsKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateSharedSwapchainsKHR")]
	#[doc = "\n\n[Khronos reference: `vkCreateSharedSwapchainsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateSharedSwapchainsKHR.html)"]
	#[inline]
	pub unsafe fn create_shared_swapchains_khr(
		&self,
		swapchain_count: u32,
		p_create_infos: *const vk::SwapchainCreateInfoKHR<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_swapchains: *mut vk::SwapchainKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			create_shared_swapchains_khr(
				self,
				swapchain_count,
				p_create_infos,
				p_allocator,
				p_swapchains,
			)
		}
	}
}

/// Call `vkDestroySurfaceKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroySurfaceKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroySurfaceKHR")]
#[doc = "\n\n[Khronos reference: `vkDestroySurfaceKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroySurfaceKHR.html)"]
pub unsafe fn destroy_surface_khr(
	instance: &Instance,
	surface: vk::SurfaceKHR,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.destroy_surface_khr
		.ok_or(CallError::MissingCommand("vkDestroySurfaceKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(instance.handle(), surface, p_allocator) };
	Ok(())
}

impl Instance {
	/// Call `vkDestroySurfaceKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroySurfaceKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroySurfaceKHR")]
	#[doc = "\n\n[Khronos reference: `vkDestroySurfaceKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroySurfaceKHR.html)"]
	#[inline]
	pub unsafe fn destroy_surface_khr(
		&self,
		surface: vk::SurfaceKHR,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_surface_khr(self, surface, p_allocator) }
	}
}

/// Call `vkGetPhysicalDeviceSurfaceSupportKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceSurfaceSupportKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceSurfaceSupportKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSurfaceSupportKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSurfaceSupportKHR.html)"]
pub unsafe fn get_physical_device_surface_support_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	queue_family_index: u32,
	surface: vk::SurfaceKHR,
	p_supported: *mut vk::Bool32,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_surface_support_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceSurfaceSupportKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, queue_family_index, surface, p_supported) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceSurfaceSupportKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceSurfaceSupportKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceSurfaceSupportKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSurfaceSupportKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSurfaceSupportKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_surface_support_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		queue_family_index: u32,
		surface: vk::SurfaceKHR,
		p_supported: *mut vk::Bool32,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_surface_support_khr(
				self,
				physical_device,
				queue_family_index,
				surface,
				p_supported,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceSurfaceCapabilitiesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceSurfaceCapabilitiesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceSurfaceCapabilitiesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSurfaceCapabilitiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html)"]
pub unsafe fn get_physical_device_surface_capabilities_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	surface: vk::SurfaceKHR,
	p_surface_capabilities: *mut vk::SurfaceCapabilitiesKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_surface_capabilities_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceSurfaceCapabilitiesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, surface, p_surface_capabilities) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceSurfaceCapabilitiesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceSurfaceCapabilitiesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceSurfaceCapabilitiesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSurfaceCapabilitiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_surface_capabilities_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		surface: vk::SurfaceKHR,
		p_surface_capabilities: *mut vk::SurfaceCapabilitiesKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_surface_capabilities_khr(
				self,
				physical_device,
				surface,
				p_surface_capabilities,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceSurfaceFormatsKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceSurfaceFormatsKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceSurfaceFormatsKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSurfaceFormatsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSurfaceFormatsKHR.html)"]
pub unsafe fn get_physical_device_surface_formats_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	surface: vk::SurfaceKHR,
	p_surface_format_count: *mut u32,
	p_surface_formats: *mut vk::SurfaceFormatKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_surface_formats_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceSurfaceFormatsKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			physical_device,
			surface,
			p_surface_format_count,
			p_surface_formats,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceSurfaceFormatsKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceSurfaceFormatsKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceSurfaceFormatsKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSurfaceFormatsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSurfaceFormatsKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_surface_formats_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		surface: vk::SurfaceKHR,
		p_surface_format_count: *mut u32,
		p_surface_formats: *mut vk::SurfaceFormatKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_surface_formats_khr(
				self,
				physical_device,
				surface,
				p_surface_format_count,
				p_surface_formats,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceSurfacePresentModesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceSurfacePresentModesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceSurfacePresentModesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSurfacePresentModesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSurfacePresentModesKHR.html)"]
pub unsafe fn get_physical_device_surface_present_modes_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	surface: vk::SurfaceKHR,
	p_present_mode_count: *mut u32,
	p_present_modes: *mut vk::PresentModeKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_surface_present_modes_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceSurfacePresentModesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			physical_device,
			surface,
			p_present_mode_count,
			p_present_modes,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceSurfacePresentModesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceSurfacePresentModesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceSurfacePresentModesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSurfacePresentModesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSurfacePresentModesKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_surface_present_modes_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		surface: vk::SurfaceKHR,
		p_present_mode_count: *mut u32,
		p_present_modes: *mut vk::PresentModeKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_surface_present_modes_khr(
				self,
				physical_device,
				surface,
				p_present_mode_count,
				p_present_modes,
			)
		}
	}
}

/// Call `vkCreateSwapchainKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateSwapchainKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateSwapchainKHR")]
#[doc = "\n\n[Khronos reference: `vkCreateSwapchainKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateSwapchainKHR.html)"]
pub unsafe fn create_swapchain_khr(
	device: &Device,
	p_create_info: *const vk::SwapchainCreateInfoKHR<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_swapchain: *mut vk::SwapchainKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_swapchain_khr
		.ok_or(CallError::MissingCommand("vkCreateSwapchainKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_create_info, p_allocator, p_swapchain) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateSwapchainKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateSwapchainKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateSwapchainKHR")]
	#[doc = "\n\n[Khronos reference: `vkCreateSwapchainKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateSwapchainKHR.html)"]
	#[inline]
	pub unsafe fn create_swapchain_khr(
		&self,
		p_create_info: *const vk::SwapchainCreateInfoKHR<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_swapchain: *mut vk::SwapchainKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_swapchain_khr(self, p_create_info, p_allocator, p_swapchain) }
	}
}

/// Call `vkDestroySwapchainKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroySwapchainKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroySwapchainKHR")]
#[doc = "\n\n[Khronos reference: `vkDestroySwapchainKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroySwapchainKHR.html)"]
pub unsafe fn destroy_swapchain_khr(
	device: &Device,
	swapchain: vk::SwapchainKHR,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_swapchain_khr
		.ok_or(CallError::MissingCommand("vkDestroySwapchainKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), swapchain, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroySwapchainKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroySwapchainKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroySwapchainKHR")]
	#[doc = "\n\n[Khronos reference: `vkDestroySwapchainKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroySwapchainKHR.html)"]
	#[inline]
	pub unsafe fn destroy_swapchain_khr(
		&self,
		swapchain: vk::SwapchainKHR,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_swapchain_khr(self, swapchain, p_allocator) }
	}
}

/// Call `vkGetSwapchainImagesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetSwapchainImagesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetSwapchainImagesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetSwapchainImagesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSwapchainImagesKHR.html)"]
pub unsafe fn get_swapchain_images_khr(
	device: &Device,
	swapchain: vk::SwapchainKHR,
	p_swapchain_image_count: *mut u32,
	p_swapchain_images: *mut vk::Image,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_swapchain_images_khr
		.ok_or(CallError::MissingCommand("vkGetSwapchainImagesKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			swapchain,
			p_swapchain_image_count,
			p_swapchain_images,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetSwapchainImagesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetSwapchainImagesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetSwapchainImagesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetSwapchainImagesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSwapchainImagesKHR.html)"]
	#[inline]
	pub unsafe fn get_swapchain_images_khr(
		&self,
		swapchain: vk::SwapchainKHR,
		p_swapchain_image_count: *mut u32,
		p_swapchain_images: *mut vk::Image,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_swapchain_images_khr(self, swapchain, p_swapchain_image_count, p_swapchain_images)
		}
	}
}

/// Call `vkAcquireNextImageKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkAcquireNextImageKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkAcquireNextImageKHR")]
#[doc = "\n\n[Khronos reference: `vkAcquireNextImageKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkAcquireNextImageKHR.html)"]
pub unsafe fn acquire_next_image_khr(
	device: &Device,
	swapchain: vk::SwapchainKHR,
	timeout: u64,
	semaphore: vk::Semaphore,
	fence: vk::Fence,
	p_image_index: *mut u32,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.acquire_next_image_khr
		.ok_or(CallError::MissingCommand("vkAcquireNextImageKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			swapchain,
			timeout,
			semaphore,
			fence,
			p_image_index,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkAcquireNextImageKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkAcquireNextImageKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkAcquireNextImageKHR")]
	#[doc = "\n\n[Khronos reference: `vkAcquireNextImageKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkAcquireNextImageKHR.html)"]
	#[inline]
	pub unsafe fn acquire_next_image_khr(
		&self,
		swapchain: vk::SwapchainKHR,
		timeout: u64,
		semaphore: vk::Semaphore,
		fence: vk::Fence,
		p_image_index: *mut u32,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { acquire_next_image_khr(self, swapchain, timeout, semaphore, fence, p_image_index) }
	}
}

/// Call `vkQueuePresentKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkQueuePresentKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkQueuePresentKHR")]
#[doc = "\n\n[Khronos reference: `vkQueuePresentKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueuePresentKHR.html)"]
pub unsafe fn queue_present_khr(
	device: &Device,
	queue: vk::Queue,
	p_present_info: *const vk::PresentInfoKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.queue_present_khr
		.ok_or(CallError::MissingCommand("vkQueuePresentKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(queue, p_present_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkQueuePresentKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkQueuePresentKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkQueuePresentKHR")]
	#[doc = "\n\n[Khronos reference: `vkQueuePresentKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueuePresentKHR.html)"]
	#[inline]
	pub unsafe fn queue_present_khr(
		&self,
		queue: vk::Queue,
		p_present_info: *const vk::PresentInfoKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { queue_present_khr(self, queue, p_present_info) }
	}
}

#[cfg(feature = "platform-vi")]
/// Call `vkCreateViSurfaceNN` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateViSurfaceNN` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateViSurfaceNN")]
#[doc = "\n\n[Khronos reference: `vkCreateViSurfaceNN`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateViSurfaceNN.html)"]
pub unsafe fn create_vi_surface_nn(
	instance: &Instance,
	p_create_info: *const vk::ViSurfaceCreateInfoNN<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_surface: *mut vk::SurfaceKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.create_vi_surface_nn
		.ok_or(CallError::MissingCommand("vkCreateViSurfaceNN"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), p_create_info, p_allocator, p_surface) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-vi")]
impl Instance {
	/// Call `vkCreateViSurfaceNN` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateViSurfaceNN` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateViSurfaceNN")]
	#[doc = "\n\n[Khronos reference: `vkCreateViSurfaceNN`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateViSurfaceNN.html)"]
	#[inline]
	pub unsafe fn create_vi_surface_nn(
		&self,
		p_create_info: *const vk::ViSurfaceCreateInfoNN<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_surface: *mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_vi_surface_nn(self, p_create_info, p_allocator, p_surface) }
	}
}

#[cfg(feature = "platform-wayland")]
/// Call `vkCreateWaylandSurfaceKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateWaylandSurfaceKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateWaylandSurfaceKHR")]
#[doc = "\n\n[Khronos reference: `vkCreateWaylandSurfaceKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateWaylandSurfaceKHR.html)"]
pub unsafe fn create_wayland_surface_khr(
	instance: &Instance,
	p_create_info: *const vk::WaylandSurfaceCreateInfoKHR<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_surface: *mut vk::SurfaceKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.create_wayland_surface_khr
		.ok_or(CallError::MissingCommand("vkCreateWaylandSurfaceKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), p_create_info, p_allocator, p_surface) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-wayland")]
impl Instance {
	/// Call `vkCreateWaylandSurfaceKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateWaylandSurfaceKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateWaylandSurfaceKHR")]
	#[doc = "\n\n[Khronos reference: `vkCreateWaylandSurfaceKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateWaylandSurfaceKHR.html)"]
	#[inline]
	pub unsafe fn create_wayland_surface_khr(
		&self,
		p_create_info: *const vk::WaylandSurfaceCreateInfoKHR<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_surface: *mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_wayland_surface_khr(self, p_create_info, p_allocator, p_surface) }
	}
}

#[cfg(feature = "platform-wayland")]
/// Call `vkGetPhysicalDeviceWaylandPresentationSupportKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceWaylandPresentationSupportKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceWaylandPresentationSupportKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceWaylandPresentationSupportKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html)"]
pub unsafe fn get_physical_device_wayland_presentation_support_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	queue_family_index: u32,
	display: *mut vk::wl_display,
) -> Result<vk::Bool32, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_wayland_presentation_support_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceWaylandPresentationSupportKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, queue_family_index, display) };
	Ok(result)
}

#[cfg(feature = "platform-wayland")]
impl Instance {
	/// Call `vkGetPhysicalDeviceWaylandPresentationSupportKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceWaylandPresentationSupportKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceWaylandPresentationSupportKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceWaylandPresentationSupportKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_wayland_presentation_support_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		queue_family_index: u32,
		display: *mut vk::wl_display,
	) -> Result<vk::Bool32, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_wayland_presentation_support_khr(
				self,
				physical_device,
				queue_family_index,
				display,
			)
		}
	}
}

#[cfg(feature = "platform-ubm")]
/// Call `vkCreateUbmSurfaceSEC` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateUbmSurfaceSEC` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateUbmSurfaceSEC")]
#[doc = "\n\n[Khronos reference: `vkCreateUbmSurfaceSEC`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateUbmSurfaceSEC.html)"]
pub unsafe fn create_ubm_surface_sec(
	instance: &Instance,
	p_create_info: *const vk::UbmSurfaceCreateInfoSEC<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_surface: *mut vk::SurfaceKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.create_ubm_surface_sec
		.ok_or(CallError::MissingCommand("vkCreateUbmSurfaceSEC"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), p_create_info, p_allocator, p_surface) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-ubm")]
impl Instance {
	/// Call `vkCreateUbmSurfaceSEC` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateUbmSurfaceSEC` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateUbmSurfaceSEC")]
	#[doc = "\n\n[Khronos reference: `vkCreateUbmSurfaceSEC`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateUbmSurfaceSEC.html)"]
	#[inline]
	pub unsafe fn create_ubm_surface_sec(
		&self,
		p_create_info: *const vk::UbmSurfaceCreateInfoSEC<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_surface: *mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_ubm_surface_sec(self, p_create_info, p_allocator, p_surface) }
	}
}

#[cfg(feature = "platform-ubm")]
/// Call `vkGetPhysicalDeviceUbmPresentationSupportSEC` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceUbmPresentationSupportSEC` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceUbmPresentationSupportSEC")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceUbmPresentationSupportSEC`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceUbmPresentationSupportSEC.html)"]
pub unsafe fn get_physical_device_ubm_presentation_support_sec(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	queue_family_index: u32,
	device: *mut vk::ubm_device,
) -> Result<vk::Bool32, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_ubm_presentation_support_sec
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceUbmPresentationSupportSEC",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, queue_family_index, device) };
	Ok(result)
}

#[cfg(feature = "platform-ubm")]
impl Instance {
	/// Call `vkGetPhysicalDeviceUbmPresentationSupportSEC` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceUbmPresentationSupportSEC` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceUbmPresentationSupportSEC")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceUbmPresentationSupportSEC`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceUbmPresentationSupportSEC.html)"]
	#[inline]
	pub unsafe fn get_physical_device_ubm_presentation_support_sec(
		&self,
		physical_device: vk::PhysicalDevice,
		queue_family_index: u32,
		device: *mut vk::ubm_device,
	) -> Result<vk::Bool32, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_ubm_presentation_support_sec(
				self,
				physical_device,
				queue_family_index,
				device,
			)
		}
	}
}

#[cfg(feature = "platform-win32")]
/// Call `vkCreateWin32SurfaceKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateWin32SurfaceKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateWin32SurfaceKHR")]
#[doc = "\n\n[Khronos reference: `vkCreateWin32SurfaceKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateWin32SurfaceKHR.html)"]
pub unsafe fn create_win32_surface_khr(
	instance: &Instance,
	p_create_info: *const vk::Win32SurfaceCreateInfoKHR<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_surface: *mut vk::SurfaceKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.create_win32_surface_khr
		.ok_or(CallError::MissingCommand("vkCreateWin32SurfaceKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), p_create_info, p_allocator, p_surface) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-win32")]
impl Instance {
	/// Call `vkCreateWin32SurfaceKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateWin32SurfaceKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateWin32SurfaceKHR")]
	#[doc = "\n\n[Khronos reference: `vkCreateWin32SurfaceKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateWin32SurfaceKHR.html)"]
	#[inline]
	pub unsafe fn create_win32_surface_khr(
		&self,
		p_create_info: *const vk::Win32SurfaceCreateInfoKHR<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_surface: *mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_win32_surface_khr(self, p_create_info, p_allocator, p_surface) }
	}
}

#[cfg(feature = "platform-win32")]
/// Call `vkGetPhysicalDeviceWin32PresentationSupportKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceWin32PresentationSupportKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceWin32PresentationSupportKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceWin32PresentationSupportKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceWin32PresentationSupportKHR.html)"]
pub unsafe fn get_physical_device_win32_presentation_support_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	queue_family_index: u32,
) -> Result<vk::Bool32, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_win32_presentation_support_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceWin32PresentationSupportKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, queue_family_index) };
	Ok(result)
}

#[cfg(feature = "platform-win32")]
impl Instance {
	/// Call `vkGetPhysicalDeviceWin32PresentationSupportKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceWin32PresentationSupportKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceWin32PresentationSupportKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceWin32PresentationSupportKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceWin32PresentationSupportKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_win32_presentation_support_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		queue_family_index: u32,
	) -> Result<vk::Bool32, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_win32_presentation_support_khr(self, physical_device, queue_family_index)
		}
	}
}

#[cfg(feature = "platform-xlib")]
/// Call `vkCreateXlibSurfaceKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateXlibSurfaceKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateXlibSurfaceKHR")]
#[doc = "\n\n[Khronos reference: `vkCreateXlibSurfaceKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateXlibSurfaceKHR.html)"]
pub unsafe fn create_xlib_surface_khr(
	instance: &Instance,
	p_create_info: *const vk::XlibSurfaceCreateInfoKHR<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_surface: *mut vk::SurfaceKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.create_xlib_surface_khr
		.ok_or(CallError::MissingCommand("vkCreateXlibSurfaceKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), p_create_info, p_allocator, p_surface) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-xlib")]
impl Instance {
	/// Call `vkCreateXlibSurfaceKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateXlibSurfaceKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateXlibSurfaceKHR")]
	#[doc = "\n\n[Khronos reference: `vkCreateXlibSurfaceKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateXlibSurfaceKHR.html)"]
	#[inline]
	pub unsafe fn create_xlib_surface_khr(
		&self,
		p_create_info: *const vk::XlibSurfaceCreateInfoKHR<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_surface: *mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_xlib_surface_khr(self, p_create_info, p_allocator, p_surface) }
	}
}

#[cfg(feature = "platform-xlib")]
/// Call `vkGetPhysicalDeviceXlibPresentationSupportKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceXlibPresentationSupportKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceXlibPresentationSupportKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceXlibPresentationSupportKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceXlibPresentationSupportKHR.html)"]
pub unsafe fn get_physical_device_xlib_presentation_support_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	queue_family_index: u32,
	dpy: *mut vk::Display,
	visual_id: vk::VisualID,
) -> Result<vk::Bool32, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_xlib_presentation_support_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceXlibPresentationSupportKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, queue_family_index, dpy, visual_id) };
	Ok(result)
}

#[cfg(feature = "platform-xlib")]
impl Instance {
	/// Call `vkGetPhysicalDeviceXlibPresentationSupportKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceXlibPresentationSupportKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceXlibPresentationSupportKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceXlibPresentationSupportKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceXlibPresentationSupportKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_xlib_presentation_support_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		queue_family_index: u32,
		dpy: *mut vk::Display,
		visual_id: vk::VisualID,
	) -> Result<vk::Bool32, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_xlib_presentation_support_khr(
				self,
				physical_device,
				queue_family_index,
				dpy,
				visual_id,
			)
		}
	}
}

#[cfg(feature = "platform-xcb")]
/// Call `vkCreateXcbSurfaceKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateXcbSurfaceKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateXcbSurfaceKHR")]
#[doc = "\n\n[Khronos reference: `vkCreateXcbSurfaceKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateXcbSurfaceKHR.html)"]
pub unsafe fn create_xcb_surface_khr(
	instance: &Instance,
	p_create_info: *const vk::XcbSurfaceCreateInfoKHR<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_surface: *mut vk::SurfaceKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.create_xcb_surface_khr
		.ok_or(CallError::MissingCommand("vkCreateXcbSurfaceKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), p_create_info, p_allocator, p_surface) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-xcb")]
impl Instance {
	/// Call `vkCreateXcbSurfaceKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateXcbSurfaceKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateXcbSurfaceKHR")]
	#[doc = "\n\n[Khronos reference: `vkCreateXcbSurfaceKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateXcbSurfaceKHR.html)"]
	#[inline]
	pub unsafe fn create_xcb_surface_khr(
		&self,
		p_create_info: *const vk::XcbSurfaceCreateInfoKHR<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_surface: *mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_xcb_surface_khr(self, p_create_info, p_allocator, p_surface) }
	}
}

#[cfg(feature = "platform-xcb")]
/// Call `vkGetPhysicalDeviceXcbPresentationSupportKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceXcbPresentationSupportKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceXcbPresentationSupportKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceXcbPresentationSupportKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceXcbPresentationSupportKHR.html)"]
pub unsafe fn get_physical_device_xcb_presentation_support_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	queue_family_index: u32,
	connection: *mut vk::xcb_connection_t,
	visual_id: vk::xcb_visualid_t,
) -> Result<vk::Bool32, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_xcb_presentation_support_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceXcbPresentationSupportKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, queue_family_index, connection, visual_id) };
	Ok(result)
}

#[cfg(feature = "platform-xcb")]
impl Instance {
	/// Call `vkGetPhysicalDeviceXcbPresentationSupportKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceXcbPresentationSupportKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceXcbPresentationSupportKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceXcbPresentationSupportKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceXcbPresentationSupportKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_xcb_presentation_support_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		queue_family_index: u32,
		connection: *mut vk::xcb_connection_t,
		visual_id: vk::xcb_visualid_t,
	) -> Result<vk::Bool32, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_xcb_presentation_support_khr(
				self,
				physical_device,
				queue_family_index,
				connection,
				visual_id,
			)
		}
	}
}

#[cfg(feature = "platform-directfb")]
/// Call `vkCreateDirectFBSurfaceEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateDirectFBSurfaceEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateDirectFBSurfaceEXT")]
#[doc = "\n\n[Khronos reference: `vkCreateDirectFBSurfaceEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDirectFBSurfaceEXT.html)"]
pub unsafe fn create_direct_fb_surface_ext(
	instance: &Instance,
	p_create_info: *const vk::DirectFBSurfaceCreateInfoEXT<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_surface: *mut vk::SurfaceKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.create_direct_fb_surface_ext
		.ok_or(CallError::MissingCommand("vkCreateDirectFBSurfaceEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), p_create_info, p_allocator, p_surface) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-directfb")]
impl Instance {
	/// Call `vkCreateDirectFBSurfaceEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateDirectFBSurfaceEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateDirectFBSurfaceEXT")]
	#[doc = "\n\n[Khronos reference: `vkCreateDirectFBSurfaceEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDirectFBSurfaceEXT.html)"]
	#[inline]
	pub unsafe fn create_direct_fb_surface_ext(
		&self,
		p_create_info: *const vk::DirectFBSurfaceCreateInfoEXT<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_surface: *mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_direct_fb_surface_ext(self, p_create_info, p_allocator, p_surface) }
	}
}

#[cfg(feature = "platform-directfb")]
/// Call `vkGetPhysicalDeviceDirectFBPresentationSupportEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceDirectFBPresentationSupportEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceDirectFBPresentationSupportEXT")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceDirectFBPresentationSupportEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html)"]
pub unsafe fn get_physical_device_direct_fb_presentation_support_ext(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	queue_family_index: u32,
	dfb: *mut vk::IDirectFB,
) -> Result<vk::Bool32, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_direct_fb_presentation_support_ext
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceDirectFBPresentationSupportEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, queue_family_index, dfb) };
	Ok(result)
}

#[cfg(feature = "platform-directfb")]
impl Instance {
	/// Call `vkGetPhysicalDeviceDirectFBPresentationSupportEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceDirectFBPresentationSupportEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceDirectFBPresentationSupportEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceDirectFBPresentationSupportEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html)"]
	#[inline]
	pub unsafe fn get_physical_device_direct_fb_presentation_support_ext(
		&self,
		physical_device: vk::PhysicalDevice,
		queue_family_index: u32,
		dfb: *mut vk::IDirectFB,
	) -> Result<vk::Bool32, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_direct_fb_presentation_support_ext(
				self,
				physical_device,
				queue_family_index,
				dfb,
			)
		}
	}
}

#[cfg(feature = "platform-fuchsia")]
/// Call `vkCreateImagePipeSurfaceFUCHSIA` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateImagePipeSurfaceFUCHSIA` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateImagePipeSurfaceFUCHSIA")]
#[doc = "\n\n[Khronos reference: `vkCreateImagePipeSurfaceFUCHSIA`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateImagePipeSurfaceFUCHSIA.html)"]
pub unsafe fn create_image_pipe_surface_fuchsia(
	instance: &Instance,
	p_create_info: *const vk::ImagePipeSurfaceCreateInfoFUCHSIA<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_surface: *mut vk::SurfaceKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.create_image_pipe_surface_fuchsia
		.ok_or(CallError::MissingCommand("vkCreateImagePipeSurfaceFUCHSIA"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), p_create_info, p_allocator, p_surface) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-fuchsia")]
impl Instance {
	/// Call `vkCreateImagePipeSurfaceFUCHSIA` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateImagePipeSurfaceFUCHSIA` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateImagePipeSurfaceFUCHSIA")]
	#[doc = "\n\n[Khronos reference: `vkCreateImagePipeSurfaceFUCHSIA`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateImagePipeSurfaceFUCHSIA.html)"]
	#[inline]
	pub unsafe fn create_image_pipe_surface_fuchsia(
		&self,
		p_create_info: *const vk::ImagePipeSurfaceCreateInfoFUCHSIA<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_surface: *mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_image_pipe_surface_fuchsia(self, p_create_info, p_allocator, p_surface) }
	}
}

#[cfg(feature = "platform-ggp")]
/// Call `vkCreateStreamDescriptorSurfaceGGP` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateStreamDescriptorSurfaceGGP` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateStreamDescriptorSurfaceGGP")]
#[doc = "\n\n[Khronos reference: `vkCreateStreamDescriptorSurfaceGGP`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateStreamDescriptorSurfaceGGP.html)"]
pub unsafe fn create_stream_descriptor_surface_ggp(
	instance: &Instance,
	p_create_info: *const vk::StreamDescriptorSurfaceCreateInfoGGP<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_surface: *mut vk::SurfaceKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		instance
			.fp()
			.create_stream_descriptor_surface_ggp
			.ok_or(CallError::MissingCommand(
				"vkCreateStreamDescriptorSurfaceGGP",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), p_create_info, p_allocator, p_surface) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-ggp")]
impl Instance {
	/// Call `vkCreateStreamDescriptorSurfaceGGP` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateStreamDescriptorSurfaceGGP` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateStreamDescriptorSurfaceGGP")]
	#[doc = "\n\n[Khronos reference: `vkCreateStreamDescriptorSurfaceGGP`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateStreamDescriptorSurfaceGGP.html)"]
	#[inline]
	pub unsafe fn create_stream_descriptor_surface_ggp(
		&self,
		p_create_info: *const vk::StreamDescriptorSurfaceCreateInfoGGP<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_surface: *mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_stream_descriptor_surface_ggp(self, p_create_info, p_allocator, p_surface) }
	}
}

#[cfg(feature = "platform-screen")]
/// Call `vkCreateScreenSurfaceQNX` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateScreenSurfaceQNX` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateScreenSurfaceQNX")]
#[doc = "\n\n[Khronos reference: `vkCreateScreenSurfaceQNX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateScreenSurfaceQNX.html)"]
pub unsafe fn create_screen_surface_qnx(
	instance: &Instance,
	p_create_info: *const vk::ScreenSurfaceCreateInfoQNX<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_surface: *mut vk::SurfaceKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.create_screen_surface_qnx
		.ok_or(CallError::MissingCommand("vkCreateScreenSurfaceQNX"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), p_create_info, p_allocator, p_surface) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-screen")]
impl Instance {
	/// Call `vkCreateScreenSurfaceQNX` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateScreenSurfaceQNX` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateScreenSurfaceQNX")]
	#[doc = "\n\n[Khronos reference: `vkCreateScreenSurfaceQNX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateScreenSurfaceQNX.html)"]
	#[inline]
	pub unsafe fn create_screen_surface_qnx(
		&self,
		p_create_info: *const vk::ScreenSurfaceCreateInfoQNX<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_surface: *mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_screen_surface_qnx(self, p_create_info, p_allocator, p_surface) }
	}
}

#[cfg(feature = "platform-screen")]
/// Call `vkGetPhysicalDeviceScreenPresentationSupportQNX` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceScreenPresentationSupportQNX` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceScreenPresentationSupportQNX")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceScreenPresentationSupportQNX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceScreenPresentationSupportQNX.html)"]
pub unsafe fn get_physical_device_screen_presentation_support_qnx(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	queue_family_index: u32,
	window: *mut vk::_screen_window,
) -> Result<vk::Bool32, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_screen_presentation_support_qnx
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceScreenPresentationSupportQNX",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, queue_family_index, window) };
	Ok(result)
}

#[cfg(feature = "platform-screen")]
impl Instance {
	/// Call `vkGetPhysicalDeviceScreenPresentationSupportQNX` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceScreenPresentationSupportQNX` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceScreenPresentationSupportQNX")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceScreenPresentationSupportQNX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceScreenPresentationSupportQNX.html)"]
	#[inline]
	pub unsafe fn get_physical_device_screen_presentation_support_qnx(
		&self,
		physical_device: vk::PhysicalDevice,
		queue_family_index: u32,
		window: *mut vk::_screen_window,
	) -> Result<vk::Bool32, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_screen_presentation_support_qnx(
				self,
				physical_device,
				queue_family_index,
				window,
			)
		}
	}
}

/// Call `vkCreateDebugReportCallbackEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateDebugReportCallbackEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateDebugReportCallbackEXT")]
#[doc = "\n\n[Khronos reference: `vkCreateDebugReportCallbackEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDebugReportCallbackEXT.html)"]
pub unsafe fn create_debug_report_callback_ext(
	instance: &Instance,
	p_create_info: *const vk::DebugReportCallbackCreateInfoEXT<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_callback: *mut vk::DebugReportCallbackEXT,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.create_debug_report_callback_ext
		.ok_or(CallError::MissingCommand("vkCreateDebugReportCallbackEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), p_create_info, p_allocator, p_callback) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkCreateDebugReportCallbackEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateDebugReportCallbackEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateDebugReportCallbackEXT")]
	#[doc = "\n\n[Khronos reference: `vkCreateDebugReportCallbackEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDebugReportCallbackEXT.html)"]
	#[inline]
	pub unsafe fn create_debug_report_callback_ext(
		&self,
		p_create_info: *const vk::DebugReportCallbackCreateInfoEXT<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_callback: *mut vk::DebugReportCallbackEXT,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_debug_report_callback_ext(self, p_create_info, p_allocator, p_callback) }
	}
}

/// Call `vkDestroyDebugReportCallbackEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyDebugReportCallbackEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyDebugReportCallbackEXT")]
#[doc = "\n\n[Khronos reference: `vkDestroyDebugReportCallbackEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyDebugReportCallbackEXT.html)"]
pub unsafe fn destroy_debug_report_callback_ext(
	instance: &Instance,
	callback: vk::DebugReportCallbackEXT,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.destroy_debug_report_callback_ext
		.ok_or(CallError::MissingCommand("vkDestroyDebugReportCallbackEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(instance.handle(), callback, p_allocator) };
	Ok(())
}

impl Instance {
	/// Call `vkDestroyDebugReportCallbackEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyDebugReportCallbackEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyDebugReportCallbackEXT")]
	#[doc = "\n\n[Khronos reference: `vkDestroyDebugReportCallbackEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyDebugReportCallbackEXT.html)"]
	#[inline]
	pub unsafe fn destroy_debug_report_callback_ext(
		&self,
		callback: vk::DebugReportCallbackEXT,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_debug_report_callback_ext(self, callback, p_allocator) }
	}
}

/// Call `vkDebugReportMessageEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDebugReportMessageEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDebugReportMessageEXT")]
#[doc = "\n\n[Khronos reference: `vkDebugReportMessageEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDebugReportMessageEXT.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn debug_report_message_ext(
	instance: &Instance,
	flags: vk::DebugReportFlagsEXT,
	object_type: vk::DebugReportObjectTypeEXT,
	object: u64,
	location: usize,
	message_code: i32,
	p_layer_prefix: *const std::ffi::c_char,
	p_message: *const std::ffi::c_char,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.debug_report_message_ext
		.ok_or(CallError::MissingCommand("vkDebugReportMessageEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			instance.handle(),
			flags,
			object_type,
			object,
			location,
			message_code,
			p_layer_prefix,
			p_message,
		)
	};
	Ok(())
}

impl Instance {
	/// Call `vkDebugReportMessageEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDebugReportMessageEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDebugReportMessageEXT")]
	#[doc = "\n\n[Khronos reference: `vkDebugReportMessageEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDebugReportMessageEXT.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn debug_report_message_ext(
		&self,
		flags: vk::DebugReportFlagsEXT,
		object_type: vk::DebugReportObjectTypeEXT,
		object: u64,
		location: usize,
		message_code: i32,
		p_layer_prefix: *const std::ffi::c_char,
		p_message: *const std::ffi::c_char,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			debug_report_message_ext(
				self,
				flags,
				object_type,
				object,
				location,
				message_code,
				p_layer_prefix,
				p_message,
			)
		}
	}
}

/// Call `vkDebugMarkerSetObjectNameEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDebugMarkerSetObjectNameEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDebugMarkerSetObjectNameEXT")]
#[doc = "\n\n[Khronos reference: `vkDebugMarkerSetObjectNameEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDebugMarkerSetObjectNameEXT.html)"]
pub unsafe fn debug_marker_set_object_name_ext(
	device: &Device,
	p_name_info: *const vk::DebugMarkerObjectNameInfoEXT<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.debug_marker_set_object_name_ext
		.ok_or(CallError::MissingCommand("vkDebugMarkerSetObjectNameEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_name_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkDebugMarkerSetObjectNameEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDebugMarkerSetObjectNameEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDebugMarkerSetObjectNameEXT")]
	#[doc = "\n\n[Khronos reference: `vkDebugMarkerSetObjectNameEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDebugMarkerSetObjectNameEXT.html)"]
	#[inline]
	pub unsafe fn debug_marker_set_object_name_ext(
		&self,
		p_name_info: *const vk::DebugMarkerObjectNameInfoEXT<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { debug_marker_set_object_name_ext(self, p_name_info) }
	}
}

/// Call `vkDebugMarkerSetObjectTagEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDebugMarkerSetObjectTagEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDebugMarkerSetObjectTagEXT")]
#[doc = "\n\n[Khronos reference: `vkDebugMarkerSetObjectTagEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDebugMarkerSetObjectTagEXT.html)"]
pub unsafe fn debug_marker_set_object_tag_ext(
	device: &Device,
	p_tag_info: *const vk::DebugMarkerObjectTagInfoEXT<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.debug_marker_set_object_tag_ext
		.ok_or(CallError::MissingCommand("vkDebugMarkerSetObjectTagEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_tag_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkDebugMarkerSetObjectTagEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDebugMarkerSetObjectTagEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDebugMarkerSetObjectTagEXT")]
	#[doc = "\n\n[Khronos reference: `vkDebugMarkerSetObjectTagEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDebugMarkerSetObjectTagEXT.html)"]
	#[inline]
	pub unsafe fn debug_marker_set_object_tag_ext(
		&self,
		p_tag_info: *const vk::DebugMarkerObjectTagInfoEXT<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { debug_marker_set_object_tag_ext(self, p_tag_info) }
	}
}

/// Call `vkCmdDebugMarkerBeginEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDebugMarkerBeginEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDebugMarkerBeginEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdDebugMarkerBeginEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDebugMarkerBeginEXT.html)"]
pub unsafe fn cmd_debug_marker_begin_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_marker_info: *const vk::DebugMarkerMarkerInfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_debug_marker_begin_ext
		.ok_or(CallError::MissingCommand("vkCmdDebugMarkerBeginEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_marker_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDebugMarkerBeginEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDebugMarkerBeginEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDebugMarkerBeginEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdDebugMarkerBeginEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDebugMarkerBeginEXT.html)"]
	#[inline]
	pub unsafe fn cmd_debug_marker_begin_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_marker_info: *const vk::DebugMarkerMarkerInfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_debug_marker_begin_ext(self, command_buffer, p_marker_info) }
	}
}

/// Call `vkCmdDebugMarkerEndEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDebugMarkerEndEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDebugMarkerEndEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdDebugMarkerEndEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDebugMarkerEndEXT.html)"]
pub unsafe fn cmd_debug_marker_end_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_debug_marker_end_ext
		.ok_or(CallError::MissingCommand("vkCmdDebugMarkerEndEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDebugMarkerEndEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDebugMarkerEndEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDebugMarkerEndEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdDebugMarkerEndEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDebugMarkerEndEXT.html)"]
	#[inline]
	pub unsafe fn cmd_debug_marker_end_ext(
		&self,
		command_buffer: vk::CommandBuffer,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_debug_marker_end_ext(self, command_buffer) }
	}
}

/// Call `vkCmdDebugMarkerInsertEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDebugMarkerInsertEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDebugMarkerInsertEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdDebugMarkerInsertEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDebugMarkerInsertEXT.html)"]
pub unsafe fn cmd_debug_marker_insert_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_marker_info: *const vk::DebugMarkerMarkerInfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_debug_marker_insert_ext
		.ok_or(CallError::MissingCommand("vkCmdDebugMarkerInsertEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_marker_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDebugMarkerInsertEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDebugMarkerInsertEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDebugMarkerInsertEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdDebugMarkerInsertEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDebugMarkerInsertEXT.html)"]
	#[inline]
	pub unsafe fn cmd_debug_marker_insert_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_marker_info: *const vk::DebugMarkerMarkerInfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_debug_marker_insert_ext(self, command_buffer, p_marker_info) }
	}
}

/// Call `vkGetPhysicalDeviceExternalImageFormatPropertiesNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceExternalImageFormatPropertiesNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceExternalImageFormatPropertiesNV")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceExternalImageFormatPropertiesNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn get_physical_device_external_image_format_properties_nv(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	format: vk::Format,
	r#type: vk::ImageType,
	tiling: vk::ImageTiling,
	usage: vk::ImageUsageFlags,
	flags: vk::ImageCreateFlags,
	external_handle_type: vk::ExternalMemoryHandleTypeFlagsNV,
	p_external_image_format_properties: *mut vk::ExternalImageFormatPropertiesNV,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_external_image_format_properties_nv
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceExternalImageFormatPropertiesNV",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			physical_device,
			format,
			r#type,
			tiling,
			usage,
			flags,
			external_handle_type,
			p_external_image_format_properties,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceExternalImageFormatPropertiesNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceExternalImageFormatPropertiesNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceExternalImageFormatPropertiesNV")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceExternalImageFormatPropertiesNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn get_physical_device_external_image_format_properties_nv(
		&self,
		physical_device: vk::PhysicalDevice,
		format: vk::Format,
		r#type: vk::ImageType,
		tiling: vk::ImageTiling,
		usage: vk::ImageUsageFlags,
		flags: vk::ImageCreateFlags,
		external_handle_type: vk::ExternalMemoryHandleTypeFlagsNV,
		p_external_image_format_properties: *mut vk::ExternalImageFormatPropertiesNV,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_external_image_format_properties_nv(
				self,
				physical_device,
				format,
				r#type,
				tiling,
				usage,
				flags,
				external_handle_type,
				p_external_image_format_properties,
			)
		}
	}
}

#[cfg(feature = "platform-win32")]
/// Call `vkGetMemoryWin32HandleNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetMemoryWin32HandleNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetMemoryWin32HandleNV")]
#[doc = "\n\n[Khronos reference: `vkGetMemoryWin32HandleNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryWin32HandleNV.html)"]
pub unsafe fn get_memory_win32_handle_nv(
	device: &Device,
	memory: vk::DeviceMemory,
	handle_type: vk::ExternalMemoryHandleTypeFlagsNV,
	p_handle: *mut vk::HANDLE,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_memory_win32_handle_nv
		.ok_or(CallError::MissingCommand("vkGetMemoryWin32HandleNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), memory, handle_type, p_handle) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-win32")]
impl Device {
	/// Call `vkGetMemoryWin32HandleNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetMemoryWin32HandleNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetMemoryWin32HandleNV")]
	#[doc = "\n\n[Khronos reference: `vkGetMemoryWin32HandleNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryWin32HandleNV.html)"]
	#[inline]
	pub unsafe fn get_memory_win32_handle_nv(
		&self,
		memory: vk::DeviceMemory,
		handle_type: vk::ExternalMemoryHandleTypeFlagsNV,
		p_handle: *mut vk::HANDLE,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_memory_win32_handle_nv(self, memory, handle_type, p_handle) }
	}
}

/// Call `vkCmdExecuteGeneratedCommandsNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdExecuteGeneratedCommandsNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdExecuteGeneratedCommandsNV")]
#[doc = "\n\n[Khronos reference: `vkCmdExecuteGeneratedCommandsNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdExecuteGeneratedCommandsNV.html)"]
pub unsafe fn cmd_execute_generated_commands_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	is_preprocessed: vk::Bool32,
	p_generated_commands_info: *const vk::GeneratedCommandsInfoNV<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_execute_generated_commands_nv
		.ok_or(CallError::MissingCommand("vkCmdExecuteGeneratedCommandsNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, is_preprocessed, p_generated_commands_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdExecuteGeneratedCommandsNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdExecuteGeneratedCommandsNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdExecuteGeneratedCommandsNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdExecuteGeneratedCommandsNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdExecuteGeneratedCommandsNV.html)"]
	#[inline]
	pub unsafe fn cmd_execute_generated_commands_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		is_preprocessed: vk::Bool32,
		p_generated_commands_info: *const vk::GeneratedCommandsInfoNV<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_execute_generated_commands_nv(
				self,
				command_buffer,
				is_preprocessed,
				p_generated_commands_info,
			)
		}
	}
}

/// Call `vkCmdPreprocessGeneratedCommandsNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdPreprocessGeneratedCommandsNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdPreprocessGeneratedCommandsNV")]
#[doc = "\n\n[Khronos reference: `vkCmdPreprocessGeneratedCommandsNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPreprocessGeneratedCommandsNV.html)"]
pub unsafe fn cmd_preprocess_generated_commands_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_generated_commands_info: *const vk::GeneratedCommandsInfoNV<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_preprocess_generated_commands_nv
			.ok_or(CallError::MissingCommand(
				"vkCmdPreprocessGeneratedCommandsNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_generated_commands_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdPreprocessGeneratedCommandsNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdPreprocessGeneratedCommandsNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdPreprocessGeneratedCommandsNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdPreprocessGeneratedCommandsNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPreprocessGeneratedCommandsNV.html)"]
	#[inline]
	pub unsafe fn cmd_preprocess_generated_commands_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		p_generated_commands_info: *const vk::GeneratedCommandsInfoNV<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_preprocess_generated_commands_nv(self, command_buffer, p_generated_commands_info) }
	}
}

/// Call `vkCmdBindPipelineShaderGroupNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindPipelineShaderGroupNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBindPipelineShaderGroupNV")]
#[doc = "\n\n[Khronos reference: `vkCmdBindPipelineShaderGroupNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindPipelineShaderGroupNV.html)"]
pub unsafe fn cmd_bind_pipeline_shader_group_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	pipeline_bind_point: vk::PipelineBindPoint,
	pipeline: vk::Pipeline,
	group_index: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_pipeline_shader_group_nv
		.ok_or(CallError::MissingCommand("vkCmdBindPipelineShaderGroupNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, pipeline_bind_point, pipeline, group_index) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBindPipelineShaderGroupNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindPipelineShaderGroupNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBindPipelineShaderGroupNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindPipelineShaderGroupNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindPipelineShaderGroupNV.html)"]
	#[inline]
	pub unsafe fn cmd_bind_pipeline_shader_group_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		pipeline_bind_point: vk::PipelineBindPoint,
		pipeline: vk::Pipeline,
		group_index: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_bind_pipeline_shader_group_nv(
				self,
				command_buffer,
				pipeline_bind_point,
				pipeline,
				group_index,
			)
		}
	}
}

/// Call `vkGetGeneratedCommandsMemoryRequirementsNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetGeneratedCommandsMemoryRequirementsNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetGeneratedCommandsMemoryRequirementsNV")]
#[doc = "\n\n[Khronos reference: `vkGetGeneratedCommandsMemoryRequirementsNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetGeneratedCommandsMemoryRequirementsNV.html)"]
pub unsafe fn get_generated_commands_memory_requirements_nv(
	device: &Device,
	p_info: *const vk::GeneratedCommandsMemoryRequirementsInfoNV<'_>,
	p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_generated_commands_memory_requirements_nv
		.ok_or(CallError::MissingCommand(
			"vkGetGeneratedCommandsMemoryRequirementsNV",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_info, p_memory_requirements) };
	Ok(())
}

impl Device {
	/// Call `vkGetGeneratedCommandsMemoryRequirementsNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetGeneratedCommandsMemoryRequirementsNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetGeneratedCommandsMemoryRequirementsNV")]
	#[doc = "\n\n[Khronos reference: `vkGetGeneratedCommandsMemoryRequirementsNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetGeneratedCommandsMemoryRequirementsNV.html)"]
	#[inline]
	pub unsafe fn get_generated_commands_memory_requirements_nv(
		&self,
		p_info: *const vk::GeneratedCommandsMemoryRequirementsInfoNV<'_>,
		p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_generated_commands_memory_requirements_nv(self, p_info, p_memory_requirements) }
	}
}

/// Call `vkCreateIndirectCommandsLayoutNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateIndirectCommandsLayoutNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateIndirectCommandsLayoutNV")]
#[doc = "\n\n[Khronos reference: `vkCreateIndirectCommandsLayoutNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateIndirectCommandsLayoutNV.html)"]
pub unsafe fn create_indirect_commands_layout_nv(
	device: &Device,
	p_create_info: *const vk::IndirectCommandsLayoutCreateInfoNV<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_indirect_commands_layout: *mut vk::IndirectCommandsLayoutNV,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.create_indirect_commands_layout_nv
			.ok_or(CallError::MissingCommand(
				"vkCreateIndirectCommandsLayoutNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_create_info,
			p_allocator,
			p_indirect_commands_layout,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateIndirectCommandsLayoutNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateIndirectCommandsLayoutNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateIndirectCommandsLayoutNV")]
	#[doc = "\n\n[Khronos reference: `vkCreateIndirectCommandsLayoutNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateIndirectCommandsLayoutNV.html)"]
	#[inline]
	pub unsafe fn create_indirect_commands_layout_nv(
		&self,
		p_create_info: *const vk::IndirectCommandsLayoutCreateInfoNV<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_indirect_commands_layout: *mut vk::IndirectCommandsLayoutNV,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			create_indirect_commands_layout_nv(
				self,
				p_create_info,
				p_allocator,
				p_indirect_commands_layout,
			)
		}
	}
}

/// Call `vkDestroyIndirectCommandsLayoutNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyIndirectCommandsLayoutNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyIndirectCommandsLayoutNV")]
#[doc = "\n\n[Khronos reference: `vkDestroyIndirectCommandsLayoutNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyIndirectCommandsLayoutNV.html)"]
pub unsafe fn destroy_indirect_commands_layout_nv(
	device: &Device,
	indirect_commands_layout: vk::IndirectCommandsLayoutNV,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.destroy_indirect_commands_layout_nv
			.ok_or(CallError::MissingCommand(
				"vkDestroyIndirectCommandsLayoutNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), indirect_commands_layout, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyIndirectCommandsLayoutNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyIndirectCommandsLayoutNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyIndirectCommandsLayoutNV")]
	#[doc = "\n\n[Khronos reference: `vkDestroyIndirectCommandsLayoutNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyIndirectCommandsLayoutNV.html)"]
	#[inline]
	pub unsafe fn destroy_indirect_commands_layout_nv(
		&self,
		indirect_commands_layout: vk::IndirectCommandsLayoutNV,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_indirect_commands_layout_nv(self, indirect_commands_layout, p_allocator) }
	}
}

/// Call `vkCmdExecuteGeneratedCommandsEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdExecuteGeneratedCommandsEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdExecuteGeneratedCommandsEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdExecuteGeneratedCommandsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdExecuteGeneratedCommandsEXT.html)"]
pub unsafe fn cmd_execute_generated_commands_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	is_preprocessed: vk::Bool32,
	p_generated_commands_info: *const vk::GeneratedCommandsInfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_execute_generated_commands_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdExecuteGeneratedCommandsEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, is_preprocessed, p_generated_commands_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdExecuteGeneratedCommandsEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdExecuteGeneratedCommandsEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdExecuteGeneratedCommandsEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdExecuteGeneratedCommandsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdExecuteGeneratedCommandsEXT.html)"]
	#[inline]
	pub unsafe fn cmd_execute_generated_commands_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		is_preprocessed: vk::Bool32,
		p_generated_commands_info: *const vk::GeneratedCommandsInfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_execute_generated_commands_ext(
				self,
				command_buffer,
				is_preprocessed,
				p_generated_commands_info,
			)
		}
	}
}

/// Call `vkCmdPreprocessGeneratedCommandsEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdPreprocessGeneratedCommandsEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdPreprocessGeneratedCommandsEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdPreprocessGeneratedCommandsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPreprocessGeneratedCommandsEXT.html)"]
pub unsafe fn cmd_preprocess_generated_commands_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_generated_commands_info: *const vk::GeneratedCommandsInfoEXT<'_>,
	state_command_buffer: vk::CommandBuffer,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_preprocess_generated_commands_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdPreprocessGeneratedCommandsEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			p_generated_commands_info,
			state_command_buffer,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdPreprocessGeneratedCommandsEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdPreprocessGeneratedCommandsEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdPreprocessGeneratedCommandsEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdPreprocessGeneratedCommandsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPreprocessGeneratedCommandsEXT.html)"]
	#[inline]
	pub unsafe fn cmd_preprocess_generated_commands_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_generated_commands_info: *const vk::GeneratedCommandsInfoEXT<'_>,
		state_command_buffer: vk::CommandBuffer,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_preprocess_generated_commands_ext(
				self,
				command_buffer,
				p_generated_commands_info,
				state_command_buffer,
			)
		}
	}
}

/// Call `vkGetGeneratedCommandsMemoryRequirementsEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetGeneratedCommandsMemoryRequirementsEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetGeneratedCommandsMemoryRequirementsEXT")]
#[doc = "\n\n[Khronos reference: `vkGetGeneratedCommandsMemoryRequirementsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetGeneratedCommandsMemoryRequirementsEXT.html)"]
pub unsafe fn get_generated_commands_memory_requirements_ext(
	device: &Device,
	p_info: *const vk::GeneratedCommandsMemoryRequirementsInfoEXT<'_>,
	p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_generated_commands_memory_requirements_ext
		.ok_or(CallError::MissingCommand(
			"vkGetGeneratedCommandsMemoryRequirementsEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_info, p_memory_requirements) };
	Ok(())
}

impl Device {
	/// Call `vkGetGeneratedCommandsMemoryRequirementsEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetGeneratedCommandsMemoryRequirementsEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetGeneratedCommandsMemoryRequirementsEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetGeneratedCommandsMemoryRequirementsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetGeneratedCommandsMemoryRequirementsEXT.html)"]
	#[inline]
	pub unsafe fn get_generated_commands_memory_requirements_ext(
		&self,
		p_info: *const vk::GeneratedCommandsMemoryRequirementsInfoEXT<'_>,
		p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_generated_commands_memory_requirements_ext(self, p_info, p_memory_requirements) }
	}
}

/// Call `vkCreateIndirectCommandsLayoutEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateIndirectCommandsLayoutEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateIndirectCommandsLayoutEXT")]
#[doc = "\n\n[Khronos reference: `vkCreateIndirectCommandsLayoutEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateIndirectCommandsLayoutEXT.html)"]
pub unsafe fn create_indirect_commands_layout_ext(
	device: &Device,
	p_create_info: *const vk::IndirectCommandsLayoutCreateInfoEXT<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_indirect_commands_layout: *mut vk::IndirectCommandsLayoutEXT,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.create_indirect_commands_layout_ext
			.ok_or(CallError::MissingCommand(
				"vkCreateIndirectCommandsLayoutEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_create_info,
			p_allocator,
			p_indirect_commands_layout,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateIndirectCommandsLayoutEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateIndirectCommandsLayoutEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateIndirectCommandsLayoutEXT")]
	#[doc = "\n\n[Khronos reference: `vkCreateIndirectCommandsLayoutEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateIndirectCommandsLayoutEXT.html)"]
	#[inline]
	pub unsafe fn create_indirect_commands_layout_ext(
		&self,
		p_create_info: *const vk::IndirectCommandsLayoutCreateInfoEXT<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_indirect_commands_layout: *mut vk::IndirectCommandsLayoutEXT,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			create_indirect_commands_layout_ext(
				self,
				p_create_info,
				p_allocator,
				p_indirect_commands_layout,
			)
		}
	}
}

/// Call `vkDestroyIndirectCommandsLayoutEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyIndirectCommandsLayoutEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyIndirectCommandsLayoutEXT")]
#[doc = "\n\n[Khronos reference: `vkDestroyIndirectCommandsLayoutEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyIndirectCommandsLayoutEXT.html)"]
pub unsafe fn destroy_indirect_commands_layout_ext(
	device: &Device,
	indirect_commands_layout: vk::IndirectCommandsLayoutEXT,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.destroy_indirect_commands_layout_ext
			.ok_or(CallError::MissingCommand(
				"vkDestroyIndirectCommandsLayoutEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), indirect_commands_layout, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyIndirectCommandsLayoutEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyIndirectCommandsLayoutEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyIndirectCommandsLayoutEXT")]
	#[doc = "\n\n[Khronos reference: `vkDestroyIndirectCommandsLayoutEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyIndirectCommandsLayoutEXT.html)"]
	#[inline]
	pub unsafe fn destroy_indirect_commands_layout_ext(
		&self,
		indirect_commands_layout: vk::IndirectCommandsLayoutEXT,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_indirect_commands_layout_ext(self, indirect_commands_layout, p_allocator) }
	}
}

/// Call `vkCreateIndirectExecutionSetEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateIndirectExecutionSetEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateIndirectExecutionSetEXT")]
#[doc = "\n\n[Khronos reference: `vkCreateIndirectExecutionSetEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateIndirectExecutionSetEXT.html)"]
pub unsafe fn create_indirect_execution_set_ext(
	device: &Device,
	p_create_info: *const vk::IndirectExecutionSetCreateInfoEXT<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_indirect_execution_set: *mut vk::IndirectExecutionSetEXT,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_indirect_execution_set_ext
		.ok_or(CallError::MissingCommand("vkCreateIndirectExecutionSetEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_create_info,
			p_allocator,
			p_indirect_execution_set,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateIndirectExecutionSetEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateIndirectExecutionSetEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateIndirectExecutionSetEXT")]
	#[doc = "\n\n[Khronos reference: `vkCreateIndirectExecutionSetEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateIndirectExecutionSetEXT.html)"]
	#[inline]
	pub unsafe fn create_indirect_execution_set_ext(
		&self,
		p_create_info: *const vk::IndirectExecutionSetCreateInfoEXT<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_indirect_execution_set: *mut vk::IndirectExecutionSetEXT,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			create_indirect_execution_set_ext(self, p_create_info, p_allocator, p_indirect_execution_set)
		}
	}
}

/// Call `vkDestroyIndirectExecutionSetEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyIndirectExecutionSetEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyIndirectExecutionSetEXT")]
#[doc = "\n\n[Khronos reference: `vkDestroyIndirectExecutionSetEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyIndirectExecutionSetEXT.html)"]
pub unsafe fn destroy_indirect_execution_set_ext(
	device: &Device,
	indirect_execution_set: vk::IndirectExecutionSetEXT,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.destroy_indirect_execution_set_ext
			.ok_or(CallError::MissingCommand(
				"vkDestroyIndirectExecutionSetEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), indirect_execution_set, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyIndirectExecutionSetEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyIndirectExecutionSetEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyIndirectExecutionSetEXT")]
	#[doc = "\n\n[Khronos reference: `vkDestroyIndirectExecutionSetEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyIndirectExecutionSetEXT.html)"]
	#[inline]
	pub unsafe fn destroy_indirect_execution_set_ext(
		&self,
		indirect_execution_set: vk::IndirectExecutionSetEXT,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_indirect_execution_set_ext(self, indirect_execution_set, p_allocator) }
	}
}

/// Call `vkUpdateIndirectExecutionSetPipelineEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkUpdateIndirectExecutionSetPipelineEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkUpdateIndirectExecutionSetPipelineEXT")]
#[doc = "\n\n[Khronos reference: `vkUpdateIndirectExecutionSetPipelineEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkUpdateIndirectExecutionSetPipelineEXT.html)"]
pub unsafe fn update_indirect_execution_set_pipeline_ext(
	device: &Device,
	indirect_execution_set: vk::IndirectExecutionSetEXT,
	execution_set_write_count: u32,
	p_execution_set_writes: *const vk::WriteIndirectExecutionSetPipelineEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.update_indirect_execution_set_pipeline_ext
		.ok_or(CallError::MissingCommand(
			"vkUpdateIndirectExecutionSetPipelineEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			indirect_execution_set,
			execution_set_write_count,
			p_execution_set_writes,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkUpdateIndirectExecutionSetPipelineEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkUpdateIndirectExecutionSetPipelineEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkUpdateIndirectExecutionSetPipelineEXT")]
	#[doc = "\n\n[Khronos reference: `vkUpdateIndirectExecutionSetPipelineEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkUpdateIndirectExecutionSetPipelineEXT.html)"]
	#[inline]
	pub unsafe fn update_indirect_execution_set_pipeline_ext(
		&self,
		indirect_execution_set: vk::IndirectExecutionSetEXT,
		execution_set_write_count: u32,
		p_execution_set_writes: *const vk::WriteIndirectExecutionSetPipelineEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			update_indirect_execution_set_pipeline_ext(
				self,
				indirect_execution_set,
				execution_set_write_count,
				p_execution_set_writes,
			)
		}
	}
}

/// Call `vkUpdateIndirectExecutionSetShaderEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkUpdateIndirectExecutionSetShaderEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkUpdateIndirectExecutionSetShaderEXT")]
#[doc = "\n\n[Khronos reference: `vkUpdateIndirectExecutionSetShaderEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkUpdateIndirectExecutionSetShaderEXT.html)"]
pub unsafe fn update_indirect_execution_set_shader_ext(
	device: &Device,
	indirect_execution_set: vk::IndirectExecutionSetEXT,
	execution_set_write_count: u32,
	p_execution_set_writes: *const vk::WriteIndirectExecutionSetShaderEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.update_indirect_execution_set_shader_ext
			.ok_or(CallError::MissingCommand(
				"vkUpdateIndirectExecutionSetShaderEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			indirect_execution_set,
			execution_set_write_count,
			p_execution_set_writes,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkUpdateIndirectExecutionSetShaderEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkUpdateIndirectExecutionSetShaderEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkUpdateIndirectExecutionSetShaderEXT")]
	#[doc = "\n\n[Khronos reference: `vkUpdateIndirectExecutionSetShaderEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkUpdateIndirectExecutionSetShaderEXT.html)"]
	#[inline]
	pub unsafe fn update_indirect_execution_set_shader_ext(
		&self,
		indirect_execution_set: vk::IndirectExecutionSetEXT,
		execution_set_write_count: u32,
		p_execution_set_writes: *const vk::WriteIndirectExecutionSetShaderEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			update_indirect_execution_set_shader_ext(
				self,
				indirect_execution_set,
				execution_set_write_count,
				p_execution_set_writes,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceFeatures2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceFeatures2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetPhysicalDeviceFeatures2")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceFeatures2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceFeatures2.html)"]
pub unsafe fn get_physical_device_features2(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	features: &mut vk::PhysicalDeviceFeatures2<'_>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_features2
		.ok_or(CallError::MissingCommand("vkGetPhysicalDeviceFeatures2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(physical_device, features) };
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceFeatures2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceFeatures2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetPhysicalDeviceFeatures2")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceFeatures2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceFeatures2.html)"]
	#[inline]
	pub unsafe fn get_physical_device_features2(
		&self,
		physical_device: vk::PhysicalDevice,
		features: &mut vk::PhysicalDeviceFeatures2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_physical_device_features2(self, physical_device, features) }
	}
}

/// Call `vkGetPhysicalDeviceFeatures2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceFeatures2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetPhysicalDeviceFeatures2KHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceFeatures2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceFeatures2KHR.html)"]
pub unsafe fn get_physical_device_features2_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	features: &mut vk::PhysicalDeviceFeatures2<'_>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_features2_khr
		.ok_or(CallError::MissingCommand("vkGetPhysicalDeviceFeatures2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(physical_device, features) };
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceFeatures2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceFeatures2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetPhysicalDeviceFeatures2KHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceFeatures2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceFeatures2KHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_features2_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		features: &mut vk::PhysicalDeviceFeatures2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_physical_device_features2_khr(self, physical_device, features) }
	}
}

/// Call `vkGetPhysicalDeviceProperties2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceProperties2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetPhysicalDeviceProperties2")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceProperties2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceProperties2.html)"]
pub unsafe fn get_physical_device_properties2(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	properties: &mut vk::PhysicalDeviceProperties2<'_>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_properties2
		.ok_or(CallError::MissingCommand("vkGetPhysicalDeviceProperties2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(physical_device, properties) };
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceProperties2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceProperties2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetPhysicalDeviceProperties2")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceProperties2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceProperties2.html)"]
	#[inline]
	pub unsafe fn get_physical_device_properties2(
		&self,
		physical_device: vk::PhysicalDevice,
		properties: &mut vk::PhysicalDeviceProperties2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_physical_device_properties2(self, physical_device, properties) }
	}
}

/// Call `vkGetPhysicalDeviceProperties2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceProperties2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetPhysicalDeviceProperties2KHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceProperties2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceProperties2KHR.html)"]
pub unsafe fn get_physical_device_properties2_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	properties: &mut vk::PhysicalDeviceProperties2<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		instance
			.fp()
			.get_physical_device_properties2_khr
			.ok_or(CallError::MissingCommand(
				"vkGetPhysicalDeviceProperties2KHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(physical_device, properties) };
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceProperties2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceProperties2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetPhysicalDeviceProperties2KHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceProperties2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceProperties2KHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_properties2_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		properties: &mut vk::PhysicalDeviceProperties2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_physical_device_properties2_khr(self, physical_device, properties) }
	}
}

/// Call `vkGetPhysicalDeviceFormatProperties2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceFormatProperties2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetPhysicalDeviceFormatProperties2")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceFormatProperties2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceFormatProperties2.html)"]
pub unsafe fn get_physical_device_format_properties2(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	format: vk::Format,
	format_properties: &mut vk::FormatProperties2<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		instance
			.fp()
			.get_physical_device_format_properties2
			.ok_or(CallError::MissingCommand(
				"vkGetPhysicalDeviceFormatProperties2",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(physical_device, format, format_properties) };
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceFormatProperties2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceFormatProperties2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetPhysicalDeviceFormatProperties2")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceFormatProperties2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceFormatProperties2.html)"]
	#[inline]
	pub unsafe fn get_physical_device_format_properties2(
		&self,
		physical_device: vk::PhysicalDevice,
		format: vk::Format,
		format_properties: &mut vk::FormatProperties2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_format_properties2(self, physical_device, format, format_properties)
		}
	}
}

/// Call `vkGetPhysicalDeviceFormatProperties2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceFormatProperties2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetPhysicalDeviceFormatProperties2KHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceFormatProperties2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceFormatProperties2KHR.html)"]
pub unsafe fn get_physical_device_format_properties2_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	format: vk::Format,
	format_properties: &mut vk::FormatProperties2<'_>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_format_properties2_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceFormatProperties2KHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(physical_device, format, format_properties) };
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceFormatProperties2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceFormatProperties2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetPhysicalDeviceFormatProperties2KHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceFormatProperties2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceFormatProperties2KHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_format_properties2_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		format: vk::Format,
		format_properties: &mut vk::FormatProperties2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_format_properties2_khr(self, physical_device, format, format_properties)
		}
	}
}

/// Call `vkGetPhysicalDeviceImageFormatProperties2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceImageFormatProperties2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetPhysicalDeviceImageFormatProperties2")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceImageFormatProperties2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceImageFormatProperties2.html)"]
pub unsafe fn get_physical_device_image_format_properties2(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	image_format_info: &vk::PhysicalDeviceImageFormatInfo2<'_>,
	image_format_properties: &mut vk::ImageFormatProperties2<'_>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_image_format_properties2
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceImageFormatProperties2",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result =
		unsafe { __vk_function(physical_device, image_format_info, image_format_properties) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceImageFormatProperties2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceImageFormatProperties2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetPhysicalDeviceImageFormatProperties2")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceImageFormatProperties2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceImageFormatProperties2.html)"]
	#[inline]
	pub unsafe fn get_physical_device_image_format_properties2(
		&self,
		physical_device: vk::PhysicalDevice,
		image_format_info: &vk::PhysicalDeviceImageFormatInfo2<'_>,
		image_format_properties: &mut vk::ImageFormatProperties2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_image_format_properties2(
				self,
				physical_device,
				image_format_info,
				image_format_properties,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceImageFormatProperties2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceImageFormatProperties2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetPhysicalDeviceImageFormatProperties2KHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceImageFormatProperties2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceImageFormatProperties2KHR.html)"]
pub unsafe fn get_physical_device_image_format_properties2_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	image_format_info: &vk::PhysicalDeviceImageFormatInfo2<'_>,
	image_format_properties: &mut vk::ImageFormatProperties2<'_>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_image_format_properties2_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceImageFormatProperties2KHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result =
		unsafe { __vk_function(physical_device, image_format_info, image_format_properties) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceImageFormatProperties2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceImageFormatProperties2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetPhysicalDeviceImageFormatProperties2KHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceImageFormatProperties2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceImageFormatProperties2KHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_image_format_properties2_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		image_format_info: &vk::PhysicalDeviceImageFormatInfo2<'_>,
		image_format_properties: &mut vk::ImageFormatProperties2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_image_format_properties2_khr(
				self,
				physical_device,
				image_format_info,
				image_format_properties,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceQueueFamilyProperties2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceQueueFamilyProperties2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Pass None to query the count, or Some with fully initialized output records
/// and live, valid output chains. The slice length supplies native capacity;
/// count receives the native number available/written. Some(empty) is a zero-
/// capacity fill, not a count query. No allocation, retry, header reset or chain
/// replacement occurs. Handle INCOMPLETE (result queries) or re-query for growth
/// (void queries) explicitly. Output contents after native errors follow Vulkan.
#[doc(alias = "vkGetPhysicalDeviceQueueFamilyProperties2")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceQueueFamilyProperties2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceQueueFamilyProperties2.html)"]
pub unsafe fn get_physical_device_queue_family_properties2(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	queue_family_property_count: &mut u32,
	queue_family_properties: Option<&mut [vk::QueueFamilyProperties2<'_>]>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_queue_family_properties2
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceQueueFamilyProperties2",
		))?;
	let capacity = queue_family_properties.as_ref().map(|values| values.len());
	if let Some(capacity) = capacity {
		*queue_family_property_count =
			u32::try_from(capacity).map_err(|_| CallError::CountOverflow(capacity))?;
	}
	let values = queue_family_properties.map_or(std::ptr::null_mut(), |values| values.as_mut_ptr());
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(physical_device, queue_family_property_count, values) };
	if capacity.is_some_and(|capacity| u64::from(*queue_family_property_count) > capacity as u64) {
		return Err(CallError::InvalidOutput(
			"vkGetPhysicalDeviceQueueFamilyProperties2",
		));
	}
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceQueueFamilyProperties2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceQueueFamilyProperties2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Pass None to query the count, or Some with fully initialized output records
	/// and live, valid output chains. The slice length supplies native capacity;
	/// count receives the native number available/written. Some(empty) is a zero-
	/// capacity fill, not a count query. No allocation, retry, header reset or chain
	/// replacement occurs. Handle INCOMPLETE (result queries) or re-query for growth
	/// (void queries) explicitly. Output contents after native errors follow Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceQueueFamilyProperties2")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceQueueFamilyProperties2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceQueueFamilyProperties2.html)"]
	#[inline]
	pub unsafe fn get_physical_device_queue_family_properties2(
		&self,
		physical_device: vk::PhysicalDevice,
		queue_family_property_count: &mut u32,
		queue_family_properties: Option<&mut [vk::QueueFamilyProperties2<'_>]>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_queue_family_properties2(
				self,
				physical_device,
				queue_family_property_count,
				queue_family_properties,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceQueueFamilyProperties2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceQueueFamilyProperties2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Pass None to query the count, or Some with fully initialized output records
/// and live, valid output chains. The slice length supplies native capacity;
/// count receives the native number available/written. Some(empty) is a zero-
/// capacity fill, not a count query. No allocation, retry, header reset or chain
/// replacement occurs. Handle INCOMPLETE (result queries) or re-query for growth
/// (void queries) explicitly. Output contents after native errors follow Vulkan.
#[doc(alias = "vkGetPhysicalDeviceQueueFamilyProperties2KHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceQueueFamilyProperties2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html)"]
pub unsafe fn get_physical_device_queue_family_properties2_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	queue_family_property_count: &mut u32,
	queue_family_properties: Option<&mut [vk::QueueFamilyProperties2<'_>]>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_queue_family_properties2_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceQueueFamilyProperties2KHR",
		))?;
	let capacity = queue_family_properties.as_ref().map(|values| values.len());
	if let Some(capacity) = capacity {
		*queue_family_property_count =
			u32::try_from(capacity).map_err(|_| CallError::CountOverflow(capacity))?;
	}
	let values = queue_family_properties.map_or(std::ptr::null_mut(), |values| values.as_mut_ptr());
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(physical_device, queue_family_property_count, values) };
	if capacity.is_some_and(|capacity| u64::from(*queue_family_property_count) > capacity as u64) {
		return Err(CallError::InvalidOutput(
			"vkGetPhysicalDeviceQueueFamilyProperties2KHR",
		));
	}
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceQueueFamilyProperties2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceQueueFamilyProperties2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Pass None to query the count, or Some with fully initialized output records
	/// and live, valid output chains. The slice length supplies native capacity;
	/// count receives the native number available/written. Some(empty) is a zero-
	/// capacity fill, not a count query. No allocation, retry, header reset or chain
	/// replacement occurs. Handle INCOMPLETE (result queries) or re-query for growth
	/// (void queries) explicitly. Output contents after native errors follow Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceQueueFamilyProperties2KHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceQueueFamilyProperties2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_queue_family_properties2_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		queue_family_property_count: &mut u32,
		queue_family_properties: Option<&mut [vk::QueueFamilyProperties2<'_>]>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_queue_family_properties2_khr(
				self,
				physical_device,
				queue_family_property_count,
				queue_family_properties,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceMemoryProperties2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceMemoryProperties2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetPhysicalDeviceMemoryProperties2")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceMemoryProperties2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceMemoryProperties2.html)"]
pub unsafe fn get_physical_device_memory_properties2(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	memory_properties: &mut vk::PhysicalDeviceMemoryProperties2<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		instance
			.fp()
			.get_physical_device_memory_properties2
			.ok_or(CallError::MissingCommand(
				"vkGetPhysicalDeviceMemoryProperties2",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(physical_device, memory_properties) };
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceMemoryProperties2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceMemoryProperties2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetPhysicalDeviceMemoryProperties2")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceMemoryProperties2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceMemoryProperties2.html)"]
	#[inline]
	pub unsafe fn get_physical_device_memory_properties2(
		&self,
		physical_device: vk::PhysicalDevice,
		memory_properties: &mut vk::PhysicalDeviceMemoryProperties2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_physical_device_memory_properties2(self, physical_device, memory_properties) }
	}
}

/// Call `vkGetPhysicalDeviceMemoryProperties2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceMemoryProperties2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetPhysicalDeviceMemoryProperties2KHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceMemoryProperties2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceMemoryProperties2KHR.html)"]
pub unsafe fn get_physical_device_memory_properties2_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	memory_properties: &mut vk::PhysicalDeviceMemoryProperties2<'_>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_memory_properties2_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceMemoryProperties2KHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(physical_device, memory_properties) };
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceMemoryProperties2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceMemoryProperties2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetPhysicalDeviceMemoryProperties2KHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceMemoryProperties2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceMemoryProperties2KHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_memory_properties2_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		memory_properties: &mut vk::PhysicalDeviceMemoryProperties2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_physical_device_memory_properties2_khr(self, physical_device, memory_properties) }
	}
}

/// Call `vkGetPhysicalDeviceSparseImageFormatProperties2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceSparseImageFormatProperties2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Pass None to query the count, or Some with fully initialized output records
/// and live, valid output chains. The slice length supplies native capacity;
/// count receives the native number available/written. Some(empty) is a zero-
/// capacity fill, not a count query. No allocation, retry, header reset or chain
/// replacement occurs. Handle INCOMPLETE (result queries) or re-query for growth
/// (void queries) explicitly. Output contents after native errors follow Vulkan.
#[doc(alias = "vkGetPhysicalDeviceSparseImageFormatProperties2")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSparseImageFormatProperties2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSparseImageFormatProperties2.html)"]
pub unsafe fn get_physical_device_sparse_image_format_properties2(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	format_info: &vk::PhysicalDeviceSparseImageFormatInfo2<'_>,
	property_count: &mut u32,
	properties: Option<&mut [vk::SparseImageFormatProperties2<'_>]>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_sparse_image_format_properties2
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceSparseImageFormatProperties2",
		))?;
	let capacity = properties.as_ref().map(|values| values.len());
	if let Some(capacity) = capacity {
		*property_count = u32::try_from(capacity).map_err(|_| CallError::CountOverflow(capacity))?;
	}
	let values = properties.map_or(std::ptr::null_mut(), |values| values.as_mut_ptr());
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(physical_device, format_info, property_count, values) };
	if capacity.is_some_and(|capacity| u64::from(*property_count) > capacity as u64) {
		return Err(CallError::InvalidOutput(
			"vkGetPhysicalDeviceSparseImageFormatProperties2",
		));
	}
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceSparseImageFormatProperties2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceSparseImageFormatProperties2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Pass None to query the count, or Some with fully initialized output records
	/// and live, valid output chains. The slice length supplies native capacity;
	/// count receives the native number available/written. Some(empty) is a zero-
	/// capacity fill, not a count query. No allocation, retry, header reset or chain
	/// replacement occurs. Handle INCOMPLETE (result queries) or re-query for growth
	/// (void queries) explicitly. Output contents after native errors follow Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceSparseImageFormatProperties2")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSparseImageFormatProperties2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSparseImageFormatProperties2.html)"]
	#[inline]
	pub unsafe fn get_physical_device_sparse_image_format_properties2(
		&self,
		physical_device: vk::PhysicalDevice,
		format_info: &vk::PhysicalDeviceSparseImageFormatInfo2<'_>,
		property_count: &mut u32,
		properties: Option<&mut [vk::SparseImageFormatProperties2<'_>]>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_sparse_image_format_properties2(
				self,
				physical_device,
				format_info,
				property_count,
				properties,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceSparseImageFormatProperties2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceSparseImageFormatProperties2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Pass None to query the count, or Some with fully initialized output records
/// and live, valid output chains. The slice length supplies native capacity;
/// count receives the native number available/written. Some(empty) is a zero-
/// capacity fill, not a count query. No allocation, retry, header reset or chain
/// replacement occurs. Handle INCOMPLETE (result queries) or re-query for growth
/// (void queries) explicitly. Output contents after native errors follow Vulkan.
#[doc(alias = "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSparseImageFormatProperties2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html)"]
pub unsafe fn get_physical_device_sparse_image_format_properties2_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	format_info: &vk::PhysicalDeviceSparseImageFormatInfo2<'_>,
	property_count: &mut u32,
	properties: Option<&mut [vk::SparseImageFormatProperties2<'_>]>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_sparse_image_format_properties2_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceSparseImageFormatProperties2KHR",
		))?;
	let capacity = properties.as_ref().map(|values| values.len());
	if let Some(capacity) = capacity {
		*property_count = u32::try_from(capacity).map_err(|_| CallError::CountOverflow(capacity))?;
	}
	let values = properties.map_or(std::ptr::null_mut(), |values| values.as_mut_ptr());
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(physical_device, format_info, property_count, values) };
	if capacity.is_some_and(|capacity| u64::from(*property_count) > capacity as u64) {
		return Err(CallError::InvalidOutput(
			"vkGetPhysicalDeviceSparseImageFormatProperties2KHR",
		));
	}
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceSparseImageFormatProperties2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceSparseImageFormatProperties2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Pass None to query the count, or Some with fully initialized output records
	/// and live, valid output chains. The slice length supplies native capacity;
	/// count receives the native number available/written. Some(empty) is a zero-
	/// capacity fill, not a count query. No allocation, retry, header reset or chain
	/// replacement occurs. Handle INCOMPLETE (result queries) or re-query for growth
	/// (void queries) explicitly. Output contents after native errors follow Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSparseImageFormatProperties2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_sparse_image_format_properties2_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		format_info: &vk::PhysicalDeviceSparseImageFormatInfo2<'_>,
		property_count: &mut u32,
		properties: Option<&mut [vk::SparseImageFormatProperties2<'_>]>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_sparse_image_format_properties2_khr(
				self,
				physical_device,
				format_info,
				property_count,
				properties,
			)
		}
	}
}

/// Call `vkCmdPushDescriptorSet` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdPushDescriptorSet` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdPushDescriptorSet")]
#[doc = "\n\n[Khronos reference: `vkCmdPushDescriptorSet`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushDescriptorSet.html)"]
pub unsafe fn cmd_push_descriptor_set(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	pipeline_bind_point: vk::PipelineBindPoint,
	layout: vk::PipelineLayout,
	set: u32,
	descriptor_write_count: u32,
	p_descriptor_writes: *const vk::WriteDescriptorSet<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_push_descriptor_set
		.ok_or(CallError::MissingCommand("vkCmdPushDescriptorSet"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			pipeline_bind_point,
			layout,
			set,
			descriptor_write_count,
			p_descriptor_writes,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdPushDescriptorSet` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdPushDescriptorSet` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdPushDescriptorSet")]
	#[doc = "\n\n[Khronos reference: `vkCmdPushDescriptorSet`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushDescriptorSet.html)"]
	#[inline]
	pub unsafe fn cmd_push_descriptor_set(
		&self,
		command_buffer: vk::CommandBuffer,
		pipeline_bind_point: vk::PipelineBindPoint,
		layout: vk::PipelineLayout,
		set: u32,
		descriptor_write_count: u32,
		p_descriptor_writes: *const vk::WriteDescriptorSet<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_push_descriptor_set(
				self,
				command_buffer,
				pipeline_bind_point,
				layout,
				set,
				descriptor_write_count,
				p_descriptor_writes,
			)
		}
	}
}

/// Call `vkCmdPushDescriptorSetKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdPushDescriptorSetKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdPushDescriptorSetKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdPushDescriptorSetKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushDescriptorSetKHR.html)"]
pub unsafe fn cmd_push_descriptor_set_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	pipeline_bind_point: vk::PipelineBindPoint,
	layout: vk::PipelineLayout,
	set: u32,
	descriptor_write_count: u32,
	p_descriptor_writes: *const vk::WriteDescriptorSet<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_push_descriptor_set_khr
		.ok_or(CallError::MissingCommand("vkCmdPushDescriptorSetKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			pipeline_bind_point,
			layout,
			set,
			descriptor_write_count,
			p_descriptor_writes,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdPushDescriptorSetKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdPushDescriptorSetKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdPushDescriptorSetKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdPushDescriptorSetKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushDescriptorSetKHR.html)"]
	#[inline]
	pub unsafe fn cmd_push_descriptor_set_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		pipeline_bind_point: vk::PipelineBindPoint,
		layout: vk::PipelineLayout,
		set: u32,
		descriptor_write_count: u32,
		p_descriptor_writes: *const vk::WriteDescriptorSet<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_push_descriptor_set_khr(
				self,
				command_buffer,
				pipeline_bind_point,
				layout,
				set,
				descriptor_write_count,
				p_descriptor_writes,
			)
		}
	}
}

/// Call `vkTrimCommandPool` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkTrimCommandPool` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkTrimCommandPool")]
#[doc = "\n\n[Khronos reference: `vkTrimCommandPool`](https://docs.vulkan.org/refpages/latest/refpages/source/vkTrimCommandPool.html)"]
pub unsafe fn trim_command_pool(
	device: &Device,
	command_pool: vk::CommandPool,
	flags: vk::CommandPoolTrimFlags,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.trim_command_pool
		.ok_or(CallError::MissingCommand("vkTrimCommandPool"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), command_pool, flags) };
	Ok(())
}

impl Device {
	/// Call `vkTrimCommandPool` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkTrimCommandPool` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkTrimCommandPool")]
	#[doc = "\n\n[Khronos reference: `vkTrimCommandPool`](https://docs.vulkan.org/refpages/latest/refpages/source/vkTrimCommandPool.html)"]
	#[inline]
	pub unsafe fn trim_command_pool(
		&self,
		command_pool: vk::CommandPool,
		flags: vk::CommandPoolTrimFlags,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { trim_command_pool(self, command_pool, flags) }
	}
}

/// Call `vkTrimCommandPoolKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkTrimCommandPoolKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkTrimCommandPoolKHR")]
#[doc = "\n\n[Khronos reference: `vkTrimCommandPoolKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkTrimCommandPoolKHR.html)"]
pub unsafe fn trim_command_pool_khr(
	device: &Device,
	command_pool: vk::CommandPool,
	flags: vk::CommandPoolTrimFlags,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.trim_command_pool_khr
		.ok_or(CallError::MissingCommand("vkTrimCommandPoolKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), command_pool, flags) };
	Ok(())
}

impl Device {
	/// Call `vkTrimCommandPoolKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkTrimCommandPoolKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkTrimCommandPoolKHR")]
	#[doc = "\n\n[Khronos reference: `vkTrimCommandPoolKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkTrimCommandPoolKHR.html)"]
	#[inline]
	pub unsafe fn trim_command_pool_khr(
		&self,
		command_pool: vk::CommandPool,
		flags: vk::CommandPoolTrimFlags,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { trim_command_pool_khr(self, command_pool, flags) }
	}
}

/// Call `vkGetPhysicalDeviceExternalBufferProperties` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceExternalBufferProperties` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetPhysicalDeviceExternalBufferProperties")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceExternalBufferProperties`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceExternalBufferProperties.html)"]
pub unsafe fn get_physical_device_external_buffer_properties(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	external_buffer_info: &vk::PhysicalDeviceExternalBufferInfo<'_>,
	external_buffer_properties: &mut vk::ExternalBufferProperties<'_>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_external_buffer_properties
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceExternalBufferProperties",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			physical_device,
			external_buffer_info,
			external_buffer_properties,
		)
	};
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceExternalBufferProperties` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceExternalBufferProperties` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetPhysicalDeviceExternalBufferProperties")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceExternalBufferProperties`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceExternalBufferProperties.html)"]
	#[inline]
	pub unsafe fn get_physical_device_external_buffer_properties(
		&self,
		physical_device: vk::PhysicalDevice,
		external_buffer_info: &vk::PhysicalDeviceExternalBufferInfo<'_>,
		external_buffer_properties: &mut vk::ExternalBufferProperties<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_external_buffer_properties(
				self,
				physical_device,
				external_buffer_info,
				external_buffer_properties,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceExternalBufferPropertiesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceExternalBufferPropertiesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetPhysicalDeviceExternalBufferPropertiesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceExternalBufferPropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html)"]
pub unsafe fn get_physical_device_external_buffer_properties_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	external_buffer_info: &vk::PhysicalDeviceExternalBufferInfo<'_>,
	external_buffer_properties: &mut vk::ExternalBufferProperties<'_>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_external_buffer_properties_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceExternalBufferPropertiesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			physical_device,
			external_buffer_info,
			external_buffer_properties,
		)
	};
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceExternalBufferPropertiesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceExternalBufferPropertiesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetPhysicalDeviceExternalBufferPropertiesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceExternalBufferPropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_external_buffer_properties_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		external_buffer_info: &vk::PhysicalDeviceExternalBufferInfo<'_>,
		external_buffer_properties: &mut vk::ExternalBufferProperties<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_external_buffer_properties_khr(
				self,
				physical_device,
				external_buffer_info,
				external_buffer_properties,
			)
		}
	}
}

#[cfg(feature = "platform-win32")]
/// Call `vkGetMemoryWin32HandleKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetMemoryWin32HandleKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetMemoryWin32HandleKHR")]
#[doc = "\n\n[Khronos reference: `vkGetMemoryWin32HandleKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryWin32HandleKHR.html)"]
pub unsafe fn get_memory_win32_handle_khr(
	device: &Device,
	p_get_win32_handle_info: *const vk::MemoryGetWin32HandleInfoKHR<'_>,
	p_handle: *mut vk::HANDLE,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_memory_win32_handle_khr
		.ok_or(CallError::MissingCommand("vkGetMemoryWin32HandleKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_get_win32_handle_info, p_handle) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-win32")]
impl Device {
	/// Call `vkGetMemoryWin32HandleKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetMemoryWin32HandleKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetMemoryWin32HandleKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetMemoryWin32HandleKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryWin32HandleKHR.html)"]
	#[inline]
	pub unsafe fn get_memory_win32_handle_khr(
		&self,
		p_get_win32_handle_info: *const vk::MemoryGetWin32HandleInfoKHR<'_>,
		p_handle: *mut vk::HANDLE,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_memory_win32_handle_khr(self, p_get_win32_handle_info, p_handle) }
	}
}

#[cfg(feature = "platform-win32")]
/// Call `vkGetMemoryWin32HandlePropertiesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetMemoryWin32HandlePropertiesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetMemoryWin32HandlePropertiesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetMemoryWin32HandlePropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryWin32HandlePropertiesKHR.html)"]
pub unsafe fn get_memory_win32_handle_properties_khr(
	device: &Device,
	handle_type: vk::ExternalMemoryHandleTypeFlagBits,
	handle: vk::HANDLE,
	p_memory_win32_handle_properties: *mut vk::MemoryWin32HandlePropertiesKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.get_memory_win32_handle_properties_khr
			.ok_or(CallError::MissingCommand(
				"vkGetMemoryWin32HandlePropertiesKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			handle_type,
			handle,
			p_memory_win32_handle_properties,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-win32")]
impl Device {
	/// Call `vkGetMemoryWin32HandlePropertiesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetMemoryWin32HandlePropertiesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetMemoryWin32HandlePropertiesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetMemoryWin32HandlePropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryWin32HandlePropertiesKHR.html)"]
	#[inline]
	pub unsafe fn get_memory_win32_handle_properties_khr(
		&self,
		handle_type: vk::ExternalMemoryHandleTypeFlagBits,
		handle: vk::HANDLE,
		p_memory_win32_handle_properties: *mut vk::MemoryWin32HandlePropertiesKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_memory_win32_handle_properties_khr(
				self,
				handle_type,
				handle,
				p_memory_win32_handle_properties,
			)
		}
	}
}

/// Call `vkGetMemoryFdKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetMemoryFdKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetMemoryFdKHR")]
#[doc = "\n\n[Khronos reference: `vkGetMemoryFdKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryFdKHR.html)"]
pub unsafe fn get_memory_fd_khr(
	device: &Device,
	p_get_fd_info: *const vk::MemoryGetFdInfoKHR<'_>,
	p_fd: *mut i32,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_memory_fd_khr
		.ok_or(CallError::MissingCommand("vkGetMemoryFdKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_get_fd_info, p_fd) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetMemoryFdKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetMemoryFdKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetMemoryFdKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetMemoryFdKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryFdKHR.html)"]
	#[inline]
	pub unsafe fn get_memory_fd_khr(
		&self,
		p_get_fd_info: *const vk::MemoryGetFdInfoKHR<'_>,
		p_fd: *mut i32,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_memory_fd_khr(self, p_get_fd_info, p_fd) }
	}
}

/// Call `vkGetMemoryFdPropertiesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetMemoryFdPropertiesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetMemoryFdPropertiesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetMemoryFdPropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryFdPropertiesKHR.html)"]
pub unsafe fn get_memory_fd_properties_khr(
	device: &Device,
	handle_type: vk::ExternalMemoryHandleTypeFlagBits,
	fd: i32,
	p_memory_fd_properties: *mut vk::MemoryFdPropertiesKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_memory_fd_properties_khr
		.ok_or(CallError::MissingCommand("vkGetMemoryFdPropertiesKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), handle_type, fd, p_memory_fd_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetMemoryFdPropertiesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetMemoryFdPropertiesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetMemoryFdPropertiesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetMemoryFdPropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryFdPropertiesKHR.html)"]
	#[inline]
	pub unsafe fn get_memory_fd_properties_khr(
		&self,
		handle_type: vk::ExternalMemoryHandleTypeFlagBits,
		fd: i32,
		p_memory_fd_properties: *mut vk::MemoryFdPropertiesKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_memory_fd_properties_khr(self, handle_type, fd, p_memory_fd_properties) }
	}
}

#[cfg(feature = "platform-fuchsia")]
/// Call `vkGetMemoryZirconHandleFUCHSIA` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetMemoryZirconHandleFUCHSIA` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetMemoryZirconHandleFUCHSIA")]
#[doc = "\n\n[Khronos reference: `vkGetMemoryZirconHandleFUCHSIA`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryZirconHandleFUCHSIA.html)"]
pub unsafe fn get_memory_zircon_handle_fuchsia(
	device: &Device,
	p_get_zircon_handle_info: *const vk::MemoryGetZirconHandleInfoFUCHSIA<'_>,
	p_zircon_handle: *mut vk::zx_handle_t,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_memory_zircon_handle_fuchsia
		.ok_or(CallError::MissingCommand("vkGetMemoryZirconHandleFUCHSIA"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_get_zircon_handle_info, p_zircon_handle) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-fuchsia")]
impl Device {
	/// Call `vkGetMemoryZirconHandleFUCHSIA` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetMemoryZirconHandleFUCHSIA` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetMemoryZirconHandleFUCHSIA")]
	#[doc = "\n\n[Khronos reference: `vkGetMemoryZirconHandleFUCHSIA`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryZirconHandleFUCHSIA.html)"]
	#[inline]
	pub unsafe fn get_memory_zircon_handle_fuchsia(
		&self,
		p_get_zircon_handle_info: *const vk::MemoryGetZirconHandleInfoFUCHSIA<'_>,
		p_zircon_handle: *mut vk::zx_handle_t,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_memory_zircon_handle_fuchsia(self, p_get_zircon_handle_info, p_zircon_handle) }
	}
}

#[cfg(feature = "platform-fuchsia")]
/// Call `vkGetMemoryZirconHandlePropertiesFUCHSIA` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetMemoryZirconHandlePropertiesFUCHSIA` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetMemoryZirconHandlePropertiesFUCHSIA")]
#[doc = "\n\n[Khronos reference: `vkGetMemoryZirconHandlePropertiesFUCHSIA`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryZirconHandlePropertiesFUCHSIA.html)"]
pub unsafe fn get_memory_zircon_handle_properties_fuchsia(
	device: &Device,
	handle_type: vk::ExternalMemoryHandleTypeFlagBits,
	zircon_handle: vk::zx_handle_t,
	p_memory_zircon_handle_properties: *mut vk::MemoryZirconHandlePropertiesFUCHSIA<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_memory_zircon_handle_properties_fuchsia
		.ok_or(CallError::MissingCommand(
			"vkGetMemoryZirconHandlePropertiesFUCHSIA",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			handle_type,
			zircon_handle,
			p_memory_zircon_handle_properties,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-fuchsia")]
impl Device {
	/// Call `vkGetMemoryZirconHandlePropertiesFUCHSIA` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetMemoryZirconHandlePropertiesFUCHSIA` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetMemoryZirconHandlePropertiesFUCHSIA")]
	#[doc = "\n\n[Khronos reference: `vkGetMemoryZirconHandlePropertiesFUCHSIA`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryZirconHandlePropertiesFUCHSIA.html)"]
	#[inline]
	pub unsafe fn get_memory_zircon_handle_properties_fuchsia(
		&self,
		handle_type: vk::ExternalMemoryHandleTypeFlagBits,
		zircon_handle: vk::zx_handle_t,
		p_memory_zircon_handle_properties: *mut vk::MemoryZirconHandlePropertiesFUCHSIA<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_memory_zircon_handle_properties_fuchsia(
				self,
				handle_type,
				zircon_handle,
				p_memory_zircon_handle_properties,
			)
		}
	}
}

/// Call `vkGetMemoryRemoteAddressNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetMemoryRemoteAddressNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetMemoryRemoteAddressNV")]
#[doc = "\n\n[Khronos reference: `vkGetMemoryRemoteAddressNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryRemoteAddressNV.html)"]
pub unsafe fn get_memory_remote_address_nv(
	device: &Device,
	p_memory_get_remote_address_info: *const vk::MemoryGetRemoteAddressInfoNV<'_>,
	p_address: *mut vk::RemoteAddressNV,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_memory_remote_address_nv
		.ok_or(CallError::MissingCommand("vkGetMemoryRemoteAddressNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result =
		unsafe { __vk_function(device.handle(), p_memory_get_remote_address_info, p_address) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetMemoryRemoteAddressNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetMemoryRemoteAddressNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetMemoryRemoteAddressNV")]
	#[doc = "\n\n[Khronos reference: `vkGetMemoryRemoteAddressNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryRemoteAddressNV.html)"]
	#[inline]
	pub unsafe fn get_memory_remote_address_nv(
		&self,
		p_memory_get_remote_address_info: *const vk::MemoryGetRemoteAddressInfoNV<'_>,
		p_address: *mut vk::RemoteAddressNV,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_memory_remote_address_nv(self, p_memory_get_remote_address_info, p_address) }
	}
}

/// Call `vkGetPhysicalDeviceExternalSemaphoreProperties` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceExternalSemaphoreProperties` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetPhysicalDeviceExternalSemaphoreProperties")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceExternalSemaphoreProperties`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceExternalSemaphoreProperties.html)"]
pub unsafe fn get_physical_device_external_semaphore_properties(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	external_semaphore_info: &vk::PhysicalDeviceExternalSemaphoreInfo<'_>,
	external_semaphore_properties: &mut vk::ExternalSemaphoreProperties<'_>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_external_semaphore_properties
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceExternalSemaphoreProperties",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			physical_device,
			external_semaphore_info,
			external_semaphore_properties,
		)
	};
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceExternalSemaphoreProperties` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceExternalSemaphoreProperties` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetPhysicalDeviceExternalSemaphoreProperties")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceExternalSemaphoreProperties`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceExternalSemaphoreProperties.html)"]
	#[inline]
	pub unsafe fn get_physical_device_external_semaphore_properties(
		&self,
		physical_device: vk::PhysicalDevice,
		external_semaphore_info: &vk::PhysicalDeviceExternalSemaphoreInfo<'_>,
		external_semaphore_properties: &mut vk::ExternalSemaphoreProperties<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_external_semaphore_properties(
				self,
				physical_device,
				external_semaphore_info,
				external_semaphore_properties,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceExternalSemaphorePropertiesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceExternalSemaphorePropertiesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceExternalSemaphorePropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html)"]
pub unsafe fn get_physical_device_external_semaphore_properties_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	external_semaphore_info: &vk::PhysicalDeviceExternalSemaphoreInfo<'_>,
	external_semaphore_properties: &mut vk::ExternalSemaphoreProperties<'_>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_external_semaphore_properties_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			physical_device,
			external_semaphore_info,
			external_semaphore_properties,
		)
	};
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceExternalSemaphorePropertiesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceExternalSemaphorePropertiesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceExternalSemaphorePropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_external_semaphore_properties_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		external_semaphore_info: &vk::PhysicalDeviceExternalSemaphoreInfo<'_>,
		external_semaphore_properties: &mut vk::ExternalSemaphoreProperties<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_external_semaphore_properties_khr(
				self,
				physical_device,
				external_semaphore_info,
				external_semaphore_properties,
			)
		}
	}
}

#[cfg(feature = "platform-win32")]
/// Call `vkGetSemaphoreWin32HandleKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetSemaphoreWin32HandleKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetSemaphoreWin32HandleKHR")]
#[doc = "\n\n[Khronos reference: `vkGetSemaphoreWin32HandleKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSemaphoreWin32HandleKHR.html)"]
pub unsafe fn get_semaphore_win32_handle_khr(
	device: &Device,
	p_get_win32_handle_info: *const vk::SemaphoreGetWin32HandleInfoKHR<'_>,
	p_handle: *mut vk::HANDLE,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_semaphore_win32_handle_khr
		.ok_or(CallError::MissingCommand("vkGetSemaphoreWin32HandleKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_get_win32_handle_info, p_handle) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-win32")]
impl Device {
	/// Call `vkGetSemaphoreWin32HandleKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetSemaphoreWin32HandleKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetSemaphoreWin32HandleKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetSemaphoreWin32HandleKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSemaphoreWin32HandleKHR.html)"]
	#[inline]
	pub unsafe fn get_semaphore_win32_handle_khr(
		&self,
		p_get_win32_handle_info: *const vk::SemaphoreGetWin32HandleInfoKHR<'_>,
		p_handle: *mut vk::HANDLE,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_semaphore_win32_handle_khr(self, p_get_win32_handle_info, p_handle) }
	}
}

#[cfg(feature = "platform-win32")]
/// Call `vkImportSemaphoreWin32HandleKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkImportSemaphoreWin32HandleKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkImportSemaphoreWin32HandleKHR")]
#[doc = "\n\n[Khronos reference: `vkImportSemaphoreWin32HandleKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkImportSemaphoreWin32HandleKHR.html)"]
pub unsafe fn import_semaphore_win32_handle_khr(
	device: &Device,
	p_import_semaphore_win32_handle_info: *const vk::ImportSemaphoreWin32HandleInfoKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.import_semaphore_win32_handle_khr
		.ok_or(CallError::MissingCommand("vkImportSemaphoreWin32HandleKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_import_semaphore_win32_handle_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-win32")]
impl Device {
	/// Call `vkImportSemaphoreWin32HandleKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkImportSemaphoreWin32HandleKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkImportSemaphoreWin32HandleKHR")]
	#[doc = "\n\n[Khronos reference: `vkImportSemaphoreWin32HandleKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkImportSemaphoreWin32HandleKHR.html)"]
	#[inline]
	pub unsafe fn import_semaphore_win32_handle_khr(
		&self,
		p_import_semaphore_win32_handle_info: *const vk::ImportSemaphoreWin32HandleInfoKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { import_semaphore_win32_handle_khr(self, p_import_semaphore_win32_handle_info) }
	}
}

/// Call `vkGetSemaphoreFdKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetSemaphoreFdKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetSemaphoreFdKHR")]
#[doc = "\n\n[Khronos reference: `vkGetSemaphoreFdKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSemaphoreFdKHR.html)"]
pub unsafe fn get_semaphore_fd_khr(
	device: &Device,
	p_get_fd_info: *const vk::SemaphoreGetFdInfoKHR<'_>,
	p_fd: *mut i32,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_semaphore_fd_khr
		.ok_or(CallError::MissingCommand("vkGetSemaphoreFdKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_get_fd_info, p_fd) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetSemaphoreFdKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetSemaphoreFdKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetSemaphoreFdKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetSemaphoreFdKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSemaphoreFdKHR.html)"]
	#[inline]
	pub unsafe fn get_semaphore_fd_khr(
		&self,
		p_get_fd_info: *const vk::SemaphoreGetFdInfoKHR<'_>,
		p_fd: *mut i32,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_semaphore_fd_khr(self, p_get_fd_info, p_fd) }
	}
}

/// Call `vkImportSemaphoreFdKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkImportSemaphoreFdKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkImportSemaphoreFdKHR")]
#[doc = "\n\n[Khronos reference: `vkImportSemaphoreFdKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkImportSemaphoreFdKHR.html)"]
pub unsafe fn import_semaphore_fd_khr(
	device: &Device,
	p_import_semaphore_fd_info: *const vk::ImportSemaphoreFdInfoKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.import_semaphore_fd_khr
		.ok_or(CallError::MissingCommand("vkImportSemaphoreFdKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_import_semaphore_fd_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkImportSemaphoreFdKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkImportSemaphoreFdKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkImportSemaphoreFdKHR")]
	#[doc = "\n\n[Khronos reference: `vkImportSemaphoreFdKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkImportSemaphoreFdKHR.html)"]
	#[inline]
	pub unsafe fn import_semaphore_fd_khr(
		&self,
		p_import_semaphore_fd_info: *const vk::ImportSemaphoreFdInfoKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { import_semaphore_fd_khr(self, p_import_semaphore_fd_info) }
	}
}

#[cfg(feature = "platform-fuchsia")]
/// Call `vkGetSemaphoreZirconHandleFUCHSIA` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetSemaphoreZirconHandleFUCHSIA` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetSemaphoreZirconHandleFUCHSIA")]
#[doc = "\n\n[Khronos reference: `vkGetSemaphoreZirconHandleFUCHSIA`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSemaphoreZirconHandleFUCHSIA.html)"]
pub unsafe fn get_semaphore_zircon_handle_fuchsia(
	device: &Device,
	p_get_zircon_handle_info: *const vk::SemaphoreGetZirconHandleInfoFUCHSIA<'_>,
	p_zircon_handle: *mut vk::zx_handle_t,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.get_semaphore_zircon_handle_fuchsia
			.ok_or(CallError::MissingCommand(
				"vkGetSemaphoreZirconHandleFUCHSIA",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_get_zircon_handle_info, p_zircon_handle) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-fuchsia")]
impl Device {
	/// Call `vkGetSemaphoreZirconHandleFUCHSIA` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetSemaphoreZirconHandleFUCHSIA` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetSemaphoreZirconHandleFUCHSIA")]
	#[doc = "\n\n[Khronos reference: `vkGetSemaphoreZirconHandleFUCHSIA`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSemaphoreZirconHandleFUCHSIA.html)"]
	#[inline]
	pub unsafe fn get_semaphore_zircon_handle_fuchsia(
		&self,
		p_get_zircon_handle_info: *const vk::SemaphoreGetZirconHandleInfoFUCHSIA<'_>,
		p_zircon_handle: *mut vk::zx_handle_t,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_semaphore_zircon_handle_fuchsia(self, p_get_zircon_handle_info, p_zircon_handle) }
	}
}

#[cfg(feature = "platform-fuchsia")]
/// Call `vkImportSemaphoreZirconHandleFUCHSIA` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkImportSemaphoreZirconHandleFUCHSIA` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkImportSemaphoreZirconHandleFUCHSIA")]
#[doc = "\n\n[Khronos reference: `vkImportSemaphoreZirconHandleFUCHSIA`](https://docs.vulkan.org/refpages/latest/refpages/source/vkImportSemaphoreZirconHandleFUCHSIA.html)"]
pub unsafe fn import_semaphore_zircon_handle_fuchsia(
	device: &Device,
	p_import_semaphore_zircon_handle_info: *const vk::ImportSemaphoreZirconHandleInfoFUCHSIA<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.import_semaphore_zircon_handle_fuchsia
			.ok_or(CallError::MissingCommand(
				"vkImportSemaphoreZirconHandleFUCHSIA",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_import_semaphore_zircon_handle_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-fuchsia")]
impl Device {
	/// Call `vkImportSemaphoreZirconHandleFUCHSIA` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkImportSemaphoreZirconHandleFUCHSIA` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkImportSemaphoreZirconHandleFUCHSIA")]
	#[doc = "\n\n[Khronos reference: `vkImportSemaphoreZirconHandleFUCHSIA`](https://docs.vulkan.org/refpages/latest/refpages/source/vkImportSemaphoreZirconHandleFUCHSIA.html)"]
	#[inline]
	pub unsafe fn import_semaphore_zircon_handle_fuchsia(
		&self,
		p_import_semaphore_zircon_handle_info: *const vk::ImportSemaphoreZirconHandleInfoFUCHSIA<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { import_semaphore_zircon_handle_fuchsia(self, p_import_semaphore_zircon_handle_info) }
	}
}

/// Call `vkGetPhysicalDeviceExternalFenceProperties` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceExternalFenceProperties` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetPhysicalDeviceExternalFenceProperties")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceExternalFenceProperties`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceExternalFenceProperties.html)"]
pub unsafe fn get_physical_device_external_fence_properties(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	external_fence_info: &vk::PhysicalDeviceExternalFenceInfo<'_>,
	external_fence_properties: &mut vk::ExternalFenceProperties<'_>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_external_fence_properties
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceExternalFenceProperties",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			physical_device,
			external_fence_info,
			external_fence_properties,
		)
	};
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceExternalFenceProperties` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceExternalFenceProperties` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetPhysicalDeviceExternalFenceProperties")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceExternalFenceProperties`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceExternalFenceProperties.html)"]
	#[inline]
	pub unsafe fn get_physical_device_external_fence_properties(
		&self,
		physical_device: vk::PhysicalDevice,
		external_fence_info: &vk::PhysicalDeviceExternalFenceInfo<'_>,
		external_fence_properties: &mut vk::ExternalFenceProperties<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_external_fence_properties(
				self,
				physical_device,
				external_fence_info,
				external_fence_properties,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceExternalFencePropertiesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceExternalFencePropertiesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetPhysicalDeviceExternalFencePropertiesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceExternalFencePropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceExternalFencePropertiesKHR.html)"]
pub unsafe fn get_physical_device_external_fence_properties_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	external_fence_info: &vk::PhysicalDeviceExternalFenceInfo<'_>,
	external_fence_properties: &mut vk::ExternalFenceProperties<'_>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_external_fence_properties_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceExternalFencePropertiesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			physical_device,
			external_fence_info,
			external_fence_properties,
		)
	};
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceExternalFencePropertiesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceExternalFencePropertiesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetPhysicalDeviceExternalFencePropertiesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceExternalFencePropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceExternalFencePropertiesKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_external_fence_properties_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		external_fence_info: &vk::PhysicalDeviceExternalFenceInfo<'_>,
		external_fence_properties: &mut vk::ExternalFenceProperties<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_external_fence_properties_khr(
				self,
				physical_device,
				external_fence_info,
				external_fence_properties,
			)
		}
	}
}

#[cfg(feature = "platform-win32")]
/// Call `vkGetFenceWin32HandleKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetFenceWin32HandleKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetFenceWin32HandleKHR")]
#[doc = "\n\n[Khronos reference: `vkGetFenceWin32HandleKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetFenceWin32HandleKHR.html)"]
pub unsafe fn get_fence_win32_handle_khr(
	device: &Device,
	p_get_win32_handle_info: *const vk::FenceGetWin32HandleInfoKHR<'_>,
	p_handle: *mut vk::HANDLE,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_fence_win32_handle_khr
		.ok_or(CallError::MissingCommand("vkGetFenceWin32HandleKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_get_win32_handle_info, p_handle) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-win32")]
impl Device {
	/// Call `vkGetFenceWin32HandleKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetFenceWin32HandleKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetFenceWin32HandleKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetFenceWin32HandleKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetFenceWin32HandleKHR.html)"]
	#[inline]
	pub unsafe fn get_fence_win32_handle_khr(
		&self,
		p_get_win32_handle_info: *const vk::FenceGetWin32HandleInfoKHR<'_>,
		p_handle: *mut vk::HANDLE,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_fence_win32_handle_khr(self, p_get_win32_handle_info, p_handle) }
	}
}

#[cfg(feature = "platform-win32")]
/// Call `vkImportFenceWin32HandleKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkImportFenceWin32HandleKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkImportFenceWin32HandleKHR")]
#[doc = "\n\n[Khronos reference: `vkImportFenceWin32HandleKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkImportFenceWin32HandleKHR.html)"]
pub unsafe fn import_fence_win32_handle_khr(
	device: &Device,
	p_import_fence_win32_handle_info: *const vk::ImportFenceWin32HandleInfoKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.import_fence_win32_handle_khr
		.ok_or(CallError::MissingCommand("vkImportFenceWin32HandleKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_import_fence_win32_handle_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-win32")]
impl Device {
	/// Call `vkImportFenceWin32HandleKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkImportFenceWin32HandleKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkImportFenceWin32HandleKHR")]
	#[doc = "\n\n[Khronos reference: `vkImportFenceWin32HandleKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkImportFenceWin32HandleKHR.html)"]
	#[inline]
	pub unsafe fn import_fence_win32_handle_khr(
		&self,
		p_import_fence_win32_handle_info: *const vk::ImportFenceWin32HandleInfoKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { import_fence_win32_handle_khr(self, p_import_fence_win32_handle_info) }
	}
}

/// Call `vkGetFenceFdKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetFenceFdKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetFenceFdKHR")]
#[doc = "\n\n[Khronos reference: `vkGetFenceFdKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetFenceFdKHR.html)"]
pub unsafe fn get_fence_fd_khr(
	device: &Device,
	p_get_fd_info: *const vk::FenceGetFdInfoKHR<'_>,
	p_fd: *mut i32,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_fence_fd_khr
		.ok_or(CallError::MissingCommand("vkGetFenceFdKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_get_fd_info, p_fd) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetFenceFdKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetFenceFdKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetFenceFdKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetFenceFdKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetFenceFdKHR.html)"]
	#[inline]
	pub unsafe fn get_fence_fd_khr(
		&self,
		p_get_fd_info: *const vk::FenceGetFdInfoKHR<'_>,
		p_fd: *mut i32,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_fence_fd_khr(self, p_get_fd_info, p_fd) }
	}
}

/// Call `vkImportFenceFdKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkImportFenceFdKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkImportFenceFdKHR")]
#[doc = "\n\n[Khronos reference: `vkImportFenceFdKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkImportFenceFdKHR.html)"]
pub unsafe fn import_fence_fd_khr(
	device: &Device,
	p_import_fence_fd_info: *const vk::ImportFenceFdInfoKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.import_fence_fd_khr
		.ok_or(CallError::MissingCommand("vkImportFenceFdKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_import_fence_fd_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkImportFenceFdKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkImportFenceFdKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkImportFenceFdKHR")]
	#[doc = "\n\n[Khronos reference: `vkImportFenceFdKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkImportFenceFdKHR.html)"]
	#[inline]
	pub unsafe fn import_fence_fd_khr(
		&self,
		p_import_fence_fd_info: *const vk::ImportFenceFdInfoKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { import_fence_fd_khr(self, p_import_fence_fd_info) }
	}
}

/// Call `vkReleaseDisplayEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkReleaseDisplayEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkReleaseDisplayEXT")]
#[doc = "\n\n[Khronos reference: `vkReleaseDisplayEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkReleaseDisplayEXT.html)"]
pub unsafe fn release_display_ext(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	display: vk::DisplayKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.release_display_ext
		.ok_or(CallError::MissingCommand("vkReleaseDisplayEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, display) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkReleaseDisplayEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkReleaseDisplayEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkReleaseDisplayEXT")]
	#[doc = "\n\n[Khronos reference: `vkReleaseDisplayEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkReleaseDisplayEXT.html)"]
	#[inline]
	pub unsafe fn release_display_ext(
		&self,
		physical_device: vk::PhysicalDevice,
		display: vk::DisplayKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { release_display_ext(self, physical_device, display) }
	}
}

#[cfg(feature = "platform-xlib-xrandr")]
/// Call `vkAcquireXlibDisplayEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkAcquireXlibDisplayEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkAcquireXlibDisplayEXT")]
#[doc = "\n\n[Khronos reference: `vkAcquireXlibDisplayEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkAcquireXlibDisplayEXT.html)"]
pub unsafe fn acquire_xlib_display_ext(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	dpy: *mut vk::Display,
	display: vk::DisplayKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.acquire_xlib_display_ext
		.ok_or(CallError::MissingCommand("vkAcquireXlibDisplayEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, dpy, display) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-xlib-xrandr")]
impl Instance {
	/// Call `vkAcquireXlibDisplayEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkAcquireXlibDisplayEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkAcquireXlibDisplayEXT")]
	#[doc = "\n\n[Khronos reference: `vkAcquireXlibDisplayEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkAcquireXlibDisplayEXT.html)"]
	#[inline]
	pub unsafe fn acquire_xlib_display_ext(
		&self,
		physical_device: vk::PhysicalDevice,
		dpy: *mut vk::Display,
		display: vk::DisplayKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { acquire_xlib_display_ext(self, physical_device, dpy, display) }
	}
}

#[cfg(feature = "platform-xlib-xrandr")]
/// Call `vkGetRandROutputDisplayEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetRandROutputDisplayEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetRandROutputDisplayEXT")]
#[doc = "\n\n[Khronos reference: `vkGetRandROutputDisplayEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetRandROutputDisplayEXT.html)"]
pub unsafe fn get_rand_r_output_display_ext(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	dpy: *mut vk::Display,
	rr_output: vk::RROutput,
	p_display: *mut vk::DisplayKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_rand_r_output_display_ext
		.ok_or(CallError::MissingCommand("vkGetRandROutputDisplayEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, dpy, rr_output, p_display) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-xlib-xrandr")]
impl Instance {
	/// Call `vkGetRandROutputDisplayEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetRandROutputDisplayEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetRandROutputDisplayEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetRandROutputDisplayEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetRandROutputDisplayEXT.html)"]
	#[inline]
	pub unsafe fn get_rand_r_output_display_ext(
		&self,
		physical_device: vk::PhysicalDevice,
		dpy: *mut vk::Display,
		rr_output: vk::RROutput,
		p_display: *mut vk::DisplayKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_rand_r_output_display_ext(self, physical_device, dpy, rr_output, p_display) }
	}
}

#[cfg(feature = "platform-win32")]
/// Call `vkAcquireWinrtDisplayNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkAcquireWinrtDisplayNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkAcquireWinrtDisplayNV")]
#[doc = "\n\n[Khronos reference: `vkAcquireWinrtDisplayNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkAcquireWinrtDisplayNV.html)"]
pub unsafe fn acquire_winrt_display_nv(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	display: vk::DisplayKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.acquire_winrt_display_nv
		.ok_or(CallError::MissingCommand("vkAcquireWinrtDisplayNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, display) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-win32")]
impl Instance {
	/// Call `vkAcquireWinrtDisplayNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkAcquireWinrtDisplayNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkAcquireWinrtDisplayNV")]
	#[doc = "\n\n[Khronos reference: `vkAcquireWinrtDisplayNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkAcquireWinrtDisplayNV.html)"]
	#[inline]
	pub unsafe fn acquire_winrt_display_nv(
		&self,
		physical_device: vk::PhysicalDevice,
		display: vk::DisplayKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { acquire_winrt_display_nv(self, physical_device, display) }
	}
}

#[cfg(feature = "platform-win32")]
/// Call `vkGetWinrtDisplayNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetWinrtDisplayNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetWinrtDisplayNV")]
#[doc = "\n\n[Khronos reference: `vkGetWinrtDisplayNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetWinrtDisplayNV.html)"]
pub unsafe fn get_winrt_display_nv(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	device_relative_id: u32,
	p_display: *mut vk::DisplayKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_winrt_display_nv
		.ok_or(CallError::MissingCommand("vkGetWinrtDisplayNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, device_relative_id, p_display) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-win32")]
impl Instance {
	/// Call `vkGetWinrtDisplayNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetWinrtDisplayNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetWinrtDisplayNV")]
	#[doc = "\n\n[Khronos reference: `vkGetWinrtDisplayNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetWinrtDisplayNV.html)"]
	#[inline]
	pub unsafe fn get_winrt_display_nv(
		&self,
		physical_device: vk::PhysicalDevice,
		device_relative_id: u32,
		p_display: *mut vk::DisplayKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_winrt_display_nv(self, physical_device, device_relative_id, p_display) }
	}
}

/// Call `vkDisplayPowerControlEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDisplayPowerControlEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDisplayPowerControlEXT")]
#[doc = "\n\n[Khronos reference: `vkDisplayPowerControlEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDisplayPowerControlEXT.html)"]
pub unsafe fn display_power_control_ext(
	device: &Device,
	display: vk::DisplayKHR,
	p_display_power_info: *const vk::DisplayPowerInfoEXT<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.display_power_control_ext
		.ok_or(CallError::MissingCommand("vkDisplayPowerControlEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), display, p_display_power_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkDisplayPowerControlEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDisplayPowerControlEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDisplayPowerControlEXT")]
	#[doc = "\n\n[Khronos reference: `vkDisplayPowerControlEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDisplayPowerControlEXT.html)"]
	#[inline]
	pub unsafe fn display_power_control_ext(
		&self,
		display: vk::DisplayKHR,
		p_display_power_info: *const vk::DisplayPowerInfoEXT<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { display_power_control_ext(self, display, p_display_power_info) }
	}
}

/// Call `vkRegisterDeviceEventEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkRegisterDeviceEventEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkRegisterDeviceEventEXT")]
#[doc = "\n\n[Khronos reference: `vkRegisterDeviceEventEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkRegisterDeviceEventEXT.html)"]
pub unsafe fn register_device_event_ext(
	device: &Device,
	p_device_event_info: *const vk::DeviceEventInfoEXT<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_fence: *mut vk::Fence,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.register_device_event_ext
		.ok_or(CallError::MissingCommand("vkRegisterDeviceEventEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_device_event_info, p_allocator, p_fence) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkRegisterDeviceEventEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkRegisterDeviceEventEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkRegisterDeviceEventEXT")]
	#[doc = "\n\n[Khronos reference: `vkRegisterDeviceEventEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkRegisterDeviceEventEXT.html)"]
	#[inline]
	pub unsafe fn register_device_event_ext(
		&self,
		p_device_event_info: *const vk::DeviceEventInfoEXT<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_fence: *mut vk::Fence,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { register_device_event_ext(self, p_device_event_info, p_allocator, p_fence) }
	}
}

/// Call `vkRegisterDisplayEventEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkRegisterDisplayEventEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkRegisterDisplayEventEXT")]
#[doc = "\n\n[Khronos reference: `vkRegisterDisplayEventEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkRegisterDisplayEventEXT.html)"]
pub unsafe fn register_display_event_ext(
	device: &Device,
	display: vk::DisplayKHR,
	p_display_event_info: *const vk::DisplayEventInfoEXT<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_fence: *mut vk::Fence,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.register_display_event_ext
		.ok_or(CallError::MissingCommand("vkRegisterDisplayEventEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			display,
			p_display_event_info,
			p_allocator,
			p_fence,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkRegisterDisplayEventEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkRegisterDisplayEventEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkRegisterDisplayEventEXT")]
	#[doc = "\n\n[Khronos reference: `vkRegisterDisplayEventEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkRegisterDisplayEventEXT.html)"]
	#[inline]
	pub unsafe fn register_display_event_ext(
		&self,
		display: vk::DisplayKHR,
		p_display_event_info: *const vk::DisplayEventInfoEXT<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_fence: *mut vk::Fence,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { register_display_event_ext(self, display, p_display_event_info, p_allocator, p_fence) }
	}
}

/// Call `vkGetSwapchainCounterEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetSwapchainCounterEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetSwapchainCounterEXT")]
#[doc = "\n\n[Khronos reference: `vkGetSwapchainCounterEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSwapchainCounterEXT.html)"]
pub unsafe fn get_swapchain_counter_ext(
	device: &Device,
	swapchain: vk::SwapchainKHR,
	counter: vk::SurfaceCounterFlagBitsEXT,
	p_counter_value: *mut u64,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_swapchain_counter_ext
		.ok_or(CallError::MissingCommand("vkGetSwapchainCounterEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), swapchain, counter, p_counter_value) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetSwapchainCounterEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetSwapchainCounterEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetSwapchainCounterEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetSwapchainCounterEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSwapchainCounterEXT.html)"]
	#[inline]
	pub unsafe fn get_swapchain_counter_ext(
		&self,
		swapchain: vk::SwapchainKHR,
		counter: vk::SurfaceCounterFlagBitsEXT,
		p_counter_value: *mut u64,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_swapchain_counter_ext(self, swapchain, counter, p_counter_value) }
	}
}

/// Call `vkGetPhysicalDeviceSurfaceCapabilities2EXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceSurfaceCapabilities2EXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceSurfaceCapabilities2EXT")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSurfaceCapabilities2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html)"]
pub unsafe fn get_physical_device_surface_capabilities2_ext(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	surface: vk::SurfaceKHR,
	p_surface_capabilities: *mut vk::SurfaceCapabilities2EXT<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_surface_capabilities2_ext
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceSurfaceCapabilities2EXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, surface, p_surface_capabilities) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceSurfaceCapabilities2EXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceSurfaceCapabilities2EXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceSurfaceCapabilities2EXT")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSurfaceCapabilities2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html)"]
	#[inline]
	pub unsafe fn get_physical_device_surface_capabilities2_ext(
		&self,
		physical_device: vk::PhysicalDevice,
		surface: vk::SurfaceKHR,
		p_surface_capabilities: *mut vk::SurfaceCapabilities2EXT<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_surface_capabilities2_ext(
				self,
				physical_device,
				surface,
				p_surface_capabilities,
			)
		}
	}
}

/// Call `vkEnumeratePhysicalDeviceGroups` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkEnumeratePhysicalDeviceGroups` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Pass None to query the count, or Some with fully initialized output records
/// and live, valid output chains. The slice length supplies native capacity;
/// count receives the native number available/written. Some(empty) is a zero-
/// capacity fill, not a count query. No allocation, retry, header reset or chain
/// replacement occurs. Handle INCOMPLETE (result queries) or re-query for growth
/// (void queries) explicitly. Output contents after native errors follow Vulkan.
#[doc(alias = "vkEnumeratePhysicalDeviceGroups")]
#[doc = "\n\n[Khronos reference: `vkEnumeratePhysicalDeviceGroups`](https://docs.vulkan.org/refpages/latest/refpages/source/vkEnumeratePhysicalDeviceGroups.html)"]
pub unsafe fn enumerate_physical_device_groups(
	instance: &Instance,
	physical_device_group_count: &mut u32,
	physical_device_group_properties: Option<&mut [vk::PhysicalDeviceGroupProperties<'_>]>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.enumerate_physical_device_groups
		.ok_or(CallError::MissingCommand("vkEnumeratePhysicalDeviceGroups"))?;
	let capacity = physical_device_group_properties
		.as_ref()
		.map(|values| values.len());
	if let Some(capacity) = capacity {
		*physical_device_group_count =
			u32::try_from(capacity).map_err(|_| CallError::CountOverflow(capacity))?;
	}
	let values =
		physical_device_group_properties.map_or(std::ptr::null_mut(), |values| values.as_mut_ptr());
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), physical_device_group_count, values) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	if capacity.is_some_and(|capacity| u64::from(*physical_device_group_count) > capacity as u64) {
		return Err(CallError::InvalidOutput("vkEnumeratePhysicalDeviceGroups"));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkEnumeratePhysicalDeviceGroups` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkEnumeratePhysicalDeviceGroups` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Pass None to query the count, or Some with fully initialized output records
	/// and live, valid output chains. The slice length supplies native capacity;
	/// count receives the native number available/written. Some(empty) is a zero-
	/// capacity fill, not a count query. No allocation, retry, header reset or chain
	/// replacement occurs. Handle INCOMPLETE (result queries) or re-query for growth
	/// (void queries) explicitly. Output contents after native errors follow Vulkan.
	#[doc(alias = "vkEnumeratePhysicalDeviceGroups")]
	#[doc = "\n\n[Khronos reference: `vkEnumeratePhysicalDeviceGroups`](https://docs.vulkan.org/refpages/latest/refpages/source/vkEnumeratePhysicalDeviceGroups.html)"]
	#[inline]
	pub unsafe fn enumerate_physical_device_groups(
		&self,
		physical_device_group_count: &mut u32,
		physical_device_group_properties: Option<&mut [vk::PhysicalDeviceGroupProperties<'_>]>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			enumerate_physical_device_groups(
				self,
				physical_device_group_count,
				physical_device_group_properties,
			)
		}
	}
}

/// Call `vkEnumeratePhysicalDeviceGroupsKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkEnumeratePhysicalDeviceGroupsKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Pass None to query the count, or Some with fully initialized output records
/// and live, valid output chains. The slice length supplies native capacity;
/// count receives the native number available/written. Some(empty) is a zero-
/// capacity fill, not a count query. No allocation, retry, header reset or chain
/// replacement occurs. Handle INCOMPLETE (result queries) or re-query for growth
/// (void queries) explicitly. Output contents after native errors follow Vulkan.
#[doc(alias = "vkEnumeratePhysicalDeviceGroupsKHR")]
#[doc = "\n\n[Khronos reference: `vkEnumeratePhysicalDeviceGroupsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkEnumeratePhysicalDeviceGroupsKHR.html)"]
pub unsafe fn enumerate_physical_device_groups_khr(
	instance: &Instance,
	physical_device_group_count: &mut u32,
	physical_device_group_properties: Option<&mut [vk::PhysicalDeviceGroupProperties<'_>]>,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		instance
			.fp()
			.enumerate_physical_device_groups_khr
			.ok_or(CallError::MissingCommand(
				"vkEnumeratePhysicalDeviceGroupsKHR",
			))?;
	let capacity = physical_device_group_properties
		.as_ref()
		.map(|values| values.len());
	if let Some(capacity) = capacity {
		*physical_device_group_count =
			u32::try_from(capacity).map_err(|_| CallError::CountOverflow(capacity))?;
	}
	let values =
		physical_device_group_properties.map_or(std::ptr::null_mut(), |values| values.as_mut_ptr());
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), physical_device_group_count, values) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	if capacity.is_some_and(|capacity| u64::from(*physical_device_group_count) > capacity as u64) {
		return Err(CallError::InvalidOutput(
			"vkEnumeratePhysicalDeviceGroupsKHR",
		));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkEnumeratePhysicalDeviceGroupsKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkEnumeratePhysicalDeviceGroupsKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Pass None to query the count, or Some with fully initialized output records
	/// and live, valid output chains. The slice length supplies native capacity;
	/// count receives the native number available/written. Some(empty) is a zero-
	/// capacity fill, not a count query. No allocation, retry, header reset or chain
	/// replacement occurs. Handle INCOMPLETE (result queries) or re-query for growth
	/// (void queries) explicitly. Output contents after native errors follow Vulkan.
	#[doc(alias = "vkEnumeratePhysicalDeviceGroupsKHR")]
	#[doc = "\n\n[Khronos reference: `vkEnumeratePhysicalDeviceGroupsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkEnumeratePhysicalDeviceGroupsKHR.html)"]
	#[inline]
	pub unsafe fn enumerate_physical_device_groups_khr(
		&self,
		physical_device_group_count: &mut u32,
		physical_device_group_properties: Option<&mut [vk::PhysicalDeviceGroupProperties<'_>]>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			enumerate_physical_device_groups_khr(
				self,
				physical_device_group_count,
				physical_device_group_properties,
			)
		}
	}
}

/// Call `vkGetDeviceGroupPeerMemoryFeatures` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceGroupPeerMemoryFeatures` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetDeviceGroupPeerMemoryFeatures")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceGroupPeerMemoryFeatures`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceGroupPeerMemoryFeatures.html)"]
pub unsafe fn get_device_group_peer_memory_features(
	device: &Device,
	heap_index: u32,
	local_device_index: u32,
	remote_device_index: u32,
	peer_memory_features: &mut vk::PeerMemoryFeatureFlags,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.get_device_group_peer_memory_features
			.ok_or(CallError::MissingCommand(
				"vkGetDeviceGroupPeerMemoryFeatures",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			heap_index,
			local_device_index,
			remote_device_index,
			peer_memory_features,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkGetDeviceGroupPeerMemoryFeatures` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceGroupPeerMemoryFeatures` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetDeviceGroupPeerMemoryFeatures")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceGroupPeerMemoryFeatures`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceGroupPeerMemoryFeatures.html)"]
	#[inline]
	pub unsafe fn get_device_group_peer_memory_features(
		&self,
		heap_index: u32,
		local_device_index: u32,
		remote_device_index: u32,
		peer_memory_features: &mut vk::PeerMemoryFeatureFlags,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_device_group_peer_memory_features(
				self,
				heap_index,
				local_device_index,
				remote_device_index,
				peer_memory_features,
			)
		}
	}
}

/// Call `vkGetDeviceGroupPeerMemoryFeaturesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceGroupPeerMemoryFeaturesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetDeviceGroupPeerMemoryFeaturesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceGroupPeerMemoryFeaturesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceGroupPeerMemoryFeaturesKHR.html)"]
pub unsafe fn get_device_group_peer_memory_features_khr(
	device: &Device,
	heap_index: u32,
	local_device_index: u32,
	remote_device_index: u32,
	peer_memory_features: &mut vk::PeerMemoryFeatureFlags,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_device_group_peer_memory_features_khr
		.ok_or(CallError::MissingCommand(
			"vkGetDeviceGroupPeerMemoryFeaturesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			heap_index,
			local_device_index,
			remote_device_index,
			peer_memory_features,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkGetDeviceGroupPeerMemoryFeaturesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceGroupPeerMemoryFeaturesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetDeviceGroupPeerMemoryFeaturesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceGroupPeerMemoryFeaturesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceGroupPeerMemoryFeaturesKHR.html)"]
	#[inline]
	pub unsafe fn get_device_group_peer_memory_features_khr(
		&self,
		heap_index: u32,
		local_device_index: u32,
		remote_device_index: u32,
		peer_memory_features: &mut vk::PeerMemoryFeatureFlags,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_device_group_peer_memory_features_khr(
				self,
				heap_index,
				local_device_index,
				remote_device_index,
				peer_memory_features,
			)
		}
	}
}

/// Call `vkBindBufferMemory2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkBindBufferMemory2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkBindBufferMemory2")]
#[doc = "\n\n[Khronos reference: `vkBindBufferMemory2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBindBufferMemory2.html)"]
pub unsafe fn bind_buffer_memory2(
	device: &Device,
	bind_infos: &[vk::BindBufferMemoryInfo<'_>],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.bind_buffer_memory2
		.ok_or(CallError::MissingCommand("vkBindBufferMemory2"))?;
	let bind_info_count =
		u32::try_from(bind_infos.len()).map_err(|_| CallError::CountOverflow(bind_infos.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), bind_info_count, bind_infos.as_ptr()) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkBindBufferMemory2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkBindBufferMemory2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkBindBufferMemory2")]
	#[doc = "\n\n[Khronos reference: `vkBindBufferMemory2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBindBufferMemory2.html)"]
	#[inline]
	pub unsafe fn bind_buffer_memory2(
		&self,
		bind_infos: &[vk::BindBufferMemoryInfo<'_>],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { bind_buffer_memory2(self, bind_infos) }
	}
}

/// Call `vkBindBufferMemory2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkBindBufferMemory2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkBindBufferMemory2KHR")]
#[doc = "\n\n[Khronos reference: `vkBindBufferMemory2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBindBufferMemory2KHR.html)"]
pub unsafe fn bind_buffer_memory2_khr(
	device: &Device,
	bind_infos: &[vk::BindBufferMemoryInfo<'_>],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.bind_buffer_memory2_khr
		.ok_or(CallError::MissingCommand("vkBindBufferMemory2KHR"))?;
	let bind_info_count =
		u32::try_from(bind_infos.len()).map_err(|_| CallError::CountOverflow(bind_infos.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), bind_info_count, bind_infos.as_ptr()) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkBindBufferMemory2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkBindBufferMemory2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkBindBufferMemory2KHR")]
	#[doc = "\n\n[Khronos reference: `vkBindBufferMemory2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBindBufferMemory2KHR.html)"]
	#[inline]
	pub unsafe fn bind_buffer_memory2_khr(
		&self,
		bind_infos: &[vk::BindBufferMemoryInfo<'_>],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { bind_buffer_memory2_khr(self, bind_infos) }
	}
}

/// Call `vkBindImageMemory2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkBindImageMemory2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkBindImageMemory2")]
#[doc = "\n\n[Khronos reference: `vkBindImageMemory2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBindImageMemory2.html)"]
pub unsafe fn bind_image_memory2(
	device: &Device,
	bind_infos: &[vk::BindImageMemoryInfo<'_>],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.bind_image_memory2
		.ok_or(CallError::MissingCommand("vkBindImageMemory2"))?;
	let bind_info_count =
		u32::try_from(bind_infos.len()).map_err(|_| CallError::CountOverflow(bind_infos.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), bind_info_count, bind_infos.as_ptr()) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkBindImageMemory2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkBindImageMemory2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkBindImageMemory2")]
	#[doc = "\n\n[Khronos reference: `vkBindImageMemory2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBindImageMemory2.html)"]
	#[inline]
	pub unsafe fn bind_image_memory2(
		&self,
		bind_infos: &[vk::BindImageMemoryInfo<'_>],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { bind_image_memory2(self, bind_infos) }
	}
}

/// Call `vkBindImageMemory2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkBindImageMemory2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkBindImageMemory2KHR")]
#[doc = "\n\n[Khronos reference: `vkBindImageMemory2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBindImageMemory2KHR.html)"]
pub unsafe fn bind_image_memory2_khr(
	device: &Device,
	bind_infos: &[vk::BindImageMemoryInfo<'_>],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.bind_image_memory2_khr
		.ok_or(CallError::MissingCommand("vkBindImageMemory2KHR"))?;
	let bind_info_count =
		u32::try_from(bind_infos.len()).map_err(|_| CallError::CountOverflow(bind_infos.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), bind_info_count, bind_infos.as_ptr()) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkBindImageMemory2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkBindImageMemory2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkBindImageMemory2KHR")]
	#[doc = "\n\n[Khronos reference: `vkBindImageMemory2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBindImageMemory2KHR.html)"]
	#[inline]
	pub unsafe fn bind_image_memory2_khr(
		&self,
		bind_infos: &[vk::BindImageMemoryInfo<'_>],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { bind_image_memory2_khr(self, bind_infos) }
	}
}

/// Call `vkCmdSetDeviceMask` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDeviceMask` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdSetDeviceMask")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDeviceMask`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDeviceMask.html)"]
pub unsafe fn cmd_set_device_mask(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	device_mask: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_device_mask
		.ok_or(CallError::MissingCommand("vkCmdSetDeviceMask"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, device_mask) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDeviceMask` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDeviceMask` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdSetDeviceMask")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDeviceMask`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDeviceMask.html)"]
	#[inline]
	pub unsafe fn cmd_set_device_mask(
		&self,
		command_buffer: vk::CommandBuffer,
		device_mask: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_device_mask(self, command_buffer, device_mask) }
	}
}

/// Call `vkCmdSetDeviceMaskKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDeviceMaskKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdSetDeviceMaskKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDeviceMaskKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDeviceMaskKHR.html)"]
pub unsafe fn cmd_set_device_mask_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	device_mask: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_device_mask_khr
		.ok_or(CallError::MissingCommand("vkCmdSetDeviceMaskKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, device_mask) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDeviceMaskKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDeviceMaskKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdSetDeviceMaskKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDeviceMaskKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDeviceMaskKHR.html)"]
	#[inline]
	pub unsafe fn cmd_set_device_mask_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		device_mask: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_device_mask_khr(self, command_buffer, device_mask) }
	}
}

/// Call `vkGetDeviceGroupPresentCapabilitiesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceGroupPresentCapabilitiesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeviceGroupPresentCapabilitiesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceGroupPresentCapabilitiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceGroupPresentCapabilitiesKHR.html)"]
pub unsafe fn get_device_group_present_capabilities_khr(
	device: &Device,
	p_device_group_present_capabilities: *mut vk::DeviceGroupPresentCapabilitiesKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_device_group_present_capabilities_khr
		.ok_or(CallError::MissingCommand(
			"vkGetDeviceGroupPresentCapabilitiesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_device_group_present_capabilities) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetDeviceGroupPresentCapabilitiesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceGroupPresentCapabilitiesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeviceGroupPresentCapabilitiesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceGroupPresentCapabilitiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceGroupPresentCapabilitiesKHR.html)"]
	#[inline]
	pub unsafe fn get_device_group_present_capabilities_khr(
		&self,
		p_device_group_present_capabilities: *mut vk::DeviceGroupPresentCapabilitiesKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_device_group_present_capabilities_khr(self, p_device_group_present_capabilities) }
	}
}

/// Call `vkGetDeviceGroupSurfacePresentModesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceGroupSurfacePresentModesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeviceGroupSurfacePresentModesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceGroupSurfacePresentModesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceGroupSurfacePresentModesKHR.html)"]
pub unsafe fn get_device_group_surface_present_modes_khr(
	device: &Device,
	surface: vk::SurfaceKHR,
	p_modes: *mut vk::DeviceGroupPresentModeFlagsKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_device_group_surface_present_modes_khr
		.ok_or(CallError::MissingCommand(
			"vkGetDeviceGroupSurfacePresentModesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), surface, p_modes) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetDeviceGroupSurfacePresentModesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceGroupSurfacePresentModesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeviceGroupSurfacePresentModesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceGroupSurfacePresentModesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceGroupSurfacePresentModesKHR.html)"]
	#[inline]
	pub unsafe fn get_device_group_surface_present_modes_khr(
		&self,
		surface: vk::SurfaceKHR,
		p_modes: *mut vk::DeviceGroupPresentModeFlagsKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_device_group_surface_present_modes_khr(self, surface, p_modes) }
	}
}

/// Call `vkAcquireNextImage2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkAcquireNextImage2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkAcquireNextImage2KHR")]
#[doc = "\n\n[Khronos reference: `vkAcquireNextImage2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkAcquireNextImage2KHR.html)"]
pub unsafe fn acquire_next_image2_khr(
	device: &Device,
	p_acquire_info: *const vk::AcquireNextImageInfoKHR<'_>,
	p_image_index: *mut u32,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.acquire_next_image2_khr
		.ok_or(CallError::MissingCommand("vkAcquireNextImage2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_acquire_info, p_image_index) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkAcquireNextImage2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkAcquireNextImage2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkAcquireNextImage2KHR")]
	#[doc = "\n\n[Khronos reference: `vkAcquireNextImage2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkAcquireNextImage2KHR.html)"]
	#[inline]
	pub unsafe fn acquire_next_image2_khr(
		&self,
		p_acquire_info: *const vk::AcquireNextImageInfoKHR<'_>,
		p_image_index: *mut u32,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { acquire_next_image2_khr(self, p_acquire_info, p_image_index) }
	}
}

/// Call `vkCmdDispatchBase` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDispatchBase` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdDispatchBase")]
#[doc = "\n\n[Khronos reference: `vkCmdDispatchBase`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDispatchBase.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_dispatch_base(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	base_group_x: u32,
	base_group_y: u32,
	base_group_z: u32,
	group_count_x: u32,
	group_count_y: u32,
	group_count_z: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_dispatch_base
		.ok_or(CallError::MissingCommand("vkCmdDispatchBase"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			base_group_x,
			base_group_y,
			base_group_z,
			group_count_x,
			group_count_y,
			group_count_z,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdDispatchBase` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDispatchBase` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdDispatchBase")]
	#[doc = "\n\n[Khronos reference: `vkCmdDispatchBase`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDispatchBase.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_dispatch_base(
		&self,
		command_buffer: vk::CommandBuffer,
		base_group_x: u32,
		base_group_y: u32,
		base_group_z: u32,
		group_count_x: u32,
		group_count_y: u32,
		group_count_z: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_dispatch_base(
				self,
				command_buffer,
				base_group_x,
				base_group_y,
				base_group_z,
				group_count_x,
				group_count_y,
				group_count_z,
			)
		}
	}
}

/// Call `vkCmdDispatchBaseKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDispatchBaseKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdDispatchBaseKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdDispatchBaseKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDispatchBaseKHR.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_dispatch_base_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	base_group_x: u32,
	base_group_y: u32,
	base_group_z: u32,
	group_count_x: u32,
	group_count_y: u32,
	group_count_z: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_dispatch_base_khr
		.ok_or(CallError::MissingCommand("vkCmdDispatchBaseKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			base_group_x,
			base_group_y,
			base_group_z,
			group_count_x,
			group_count_y,
			group_count_z,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdDispatchBaseKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDispatchBaseKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdDispatchBaseKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdDispatchBaseKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDispatchBaseKHR.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_dispatch_base_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		base_group_x: u32,
		base_group_y: u32,
		base_group_z: u32,
		group_count_x: u32,
		group_count_y: u32,
		group_count_z: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_dispatch_base_khr(
				self,
				command_buffer,
				base_group_x,
				base_group_y,
				base_group_z,
				group_count_x,
				group_count_y,
				group_count_z,
			)
		}
	}
}

/// Call `vkGetPhysicalDevicePresentRectanglesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDevicePresentRectanglesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDevicePresentRectanglesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDevicePresentRectanglesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDevicePresentRectanglesKHR.html)"]
pub unsafe fn get_physical_device_present_rectangles_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	surface: vk::SurfaceKHR,
	p_rect_count: *mut u32,
	p_rects: *mut vk::Rect2D,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_present_rectangles_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDevicePresentRectanglesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, surface, p_rect_count, p_rects) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDevicePresentRectanglesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDevicePresentRectanglesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDevicePresentRectanglesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDevicePresentRectanglesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDevicePresentRectanglesKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_present_rectangles_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		surface: vk::SurfaceKHR,
		p_rect_count: *mut u32,
		p_rects: *mut vk::Rect2D,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_present_rectangles_khr(
				self,
				physical_device,
				surface,
				p_rect_count,
				p_rects,
			)
		}
	}
}

/// Call `vkCreateDescriptorUpdateTemplate` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateDescriptorUpdateTemplate` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCreateDescriptorUpdateTemplate")]
#[doc = "\n\n[Khronos reference: `vkCreateDescriptorUpdateTemplate`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDescriptorUpdateTemplate.html)"]
pub unsafe fn create_descriptor_update_template(
	device: &Device,
	create_info: &vk::DescriptorUpdateTemplateCreateInfo<'_>,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<vk::DescriptorUpdateTemplate, CallError> {
	let __vk_function =
		device
			.fp()
			.create_descriptor_update_template
			.ok_or(CallError::MissingCommand(
				"vkCreateDescriptorUpdateTemplate",
			))?;
	let mut output = vk::DescriptorUpdateTemplate::NULL;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info,
			allocator.map_or(std::ptr::null(), |value| value),
			&mut output,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(output)
}

impl Device {
	/// Call `vkCreateDescriptorUpdateTemplate` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateDescriptorUpdateTemplate` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCreateDescriptorUpdateTemplate")]
	#[doc = "\n\n[Khronos reference: `vkCreateDescriptorUpdateTemplate`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDescriptorUpdateTemplate.html)"]
	#[inline]
	pub unsafe fn create_descriptor_update_template(
		&self,
		create_info: &vk::DescriptorUpdateTemplateCreateInfo<'_>,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<vk::DescriptorUpdateTemplate, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_descriptor_update_template(self, create_info, allocator) }
	}
}

/// Call `vkCreateDescriptorUpdateTemplateKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateDescriptorUpdateTemplateKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCreateDescriptorUpdateTemplateKHR")]
#[doc = "\n\n[Khronos reference: `vkCreateDescriptorUpdateTemplateKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDescriptorUpdateTemplateKHR.html)"]
pub unsafe fn create_descriptor_update_template_khr(
	device: &Device,
	create_info: &vk::DescriptorUpdateTemplateCreateInfo<'_>,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<vk::DescriptorUpdateTemplate, CallError> {
	let __vk_function =
		device
			.fp()
			.create_descriptor_update_template_khr
			.ok_or(CallError::MissingCommand(
				"vkCreateDescriptorUpdateTemplateKHR",
			))?;
	let mut output = vk::DescriptorUpdateTemplate::NULL;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info,
			allocator.map_or(std::ptr::null(), |value| value),
			&mut output,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(output)
}

impl Device {
	/// Call `vkCreateDescriptorUpdateTemplateKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateDescriptorUpdateTemplateKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCreateDescriptorUpdateTemplateKHR")]
	#[doc = "\n\n[Khronos reference: `vkCreateDescriptorUpdateTemplateKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDescriptorUpdateTemplateKHR.html)"]
	#[inline]
	pub unsafe fn create_descriptor_update_template_khr(
		&self,
		create_info: &vk::DescriptorUpdateTemplateCreateInfo<'_>,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<vk::DescriptorUpdateTemplate, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_descriptor_update_template_khr(self, create_info, allocator) }
	}
}

/// Call `vkDestroyDescriptorUpdateTemplate` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyDescriptorUpdateTemplate` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkDestroyDescriptorUpdateTemplate")]
#[doc = "\n\n[Khronos reference: `vkDestroyDescriptorUpdateTemplate`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyDescriptorUpdateTemplate.html)"]
pub unsafe fn destroy_descriptor_update_template(
	device: &Device,
	descriptor_update_template: vk::DescriptorUpdateTemplate,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.destroy_descriptor_update_template
			.ok_or(CallError::MissingCommand(
				"vkDestroyDescriptorUpdateTemplate",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			descriptor_update_template,
			allocator.map_or(std::ptr::null(), |value| value),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkDestroyDescriptorUpdateTemplate` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyDescriptorUpdateTemplate` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkDestroyDescriptorUpdateTemplate")]
	#[doc = "\n\n[Khronos reference: `vkDestroyDescriptorUpdateTemplate`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyDescriptorUpdateTemplate.html)"]
	#[inline]
	pub unsafe fn destroy_descriptor_update_template(
		&self,
		descriptor_update_template: vk::DescriptorUpdateTemplate,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_descriptor_update_template(self, descriptor_update_template, allocator) }
	}
}

/// Call `vkDestroyDescriptorUpdateTemplateKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyDescriptorUpdateTemplateKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkDestroyDescriptorUpdateTemplateKHR")]
#[doc = "\n\n[Khronos reference: `vkDestroyDescriptorUpdateTemplateKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyDescriptorUpdateTemplateKHR.html)"]
pub unsafe fn destroy_descriptor_update_template_khr(
	device: &Device,
	descriptor_update_template: vk::DescriptorUpdateTemplate,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.destroy_descriptor_update_template_khr
			.ok_or(CallError::MissingCommand(
				"vkDestroyDescriptorUpdateTemplateKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			descriptor_update_template,
			allocator.map_or(std::ptr::null(), |value| value),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkDestroyDescriptorUpdateTemplateKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyDescriptorUpdateTemplateKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkDestroyDescriptorUpdateTemplateKHR")]
	#[doc = "\n\n[Khronos reference: `vkDestroyDescriptorUpdateTemplateKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyDescriptorUpdateTemplateKHR.html)"]
	#[inline]
	pub unsafe fn destroy_descriptor_update_template_khr(
		&self,
		descriptor_update_template: vk::DescriptorUpdateTemplate,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_descriptor_update_template_khr(self, descriptor_update_template, allocator) }
	}
}

/// Call `vkUpdateDescriptorSetWithTemplate` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkUpdateDescriptorSetWithTemplate` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Data must address initialized descriptor payloads with the alignment, offsets,
/// strides and extent declared by descriptor_update_template. No byte size can
/// be inferred from this pointer; the caller guarantees the entire native read.
#[doc(alias = "vkUpdateDescriptorSetWithTemplate")]
#[doc = "\n\n[Khronos reference: `vkUpdateDescriptorSetWithTemplate`](https://docs.vulkan.org/refpages/latest/refpages/source/vkUpdateDescriptorSetWithTemplate.html)"]
pub unsafe fn update_descriptor_set_with_template(
	device: &Device,
	descriptor_set: vk::DescriptorSet,
	descriptor_update_template: vk::DescriptorUpdateTemplate,
	data: *const std::ffi::c_void,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.update_descriptor_set_with_template
			.ok_or(CallError::MissingCommand(
				"vkUpdateDescriptorSetWithTemplate",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			descriptor_set,
			descriptor_update_template,
			data,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkUpdateDescriptorSetWithTemplate` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkUpdateDescriptorSetWithTemplate` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Data must address initialized descriptor payloads with the alignment, offsets,
	/// strides and extent declared by descriptor_update_template. No byte size can
	/// be inferred from this pointer; the caller guarantees the entire native read.
	#[doc(alias = "vkUpdateDescriptorSetWithTemplate")]
	#[doc = "\n\n[Khronos reference: `vkUpdateDescriptorSetWithTemplate`](https://docs.vulkan.org/refpages/latest/refpages/source/vkUpdateDescriptorSetWithTemplate.html)"]
	#[inline]
	pub unsafe fn update_descriptor_set_with_template(
		&self,
		descriptor_set: vk::DescriptorSet,
		descriptor_update_template: vk::DescriptorUpdateTemplate,
		data: *const std::ffi::c_void,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			update_descriptor_set_with_template(self, descriptor_set, descriptor_update_template, data)
		}
	}
}

/// Call `vkUpdateDescriptorSetWithTemplateKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkUpdateDescriptorSetWithTemplateKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Data must address initialized descriptor payloads with the alignment, offsets,
/// strides and extent declared by descriptor_update_template. No byte size can
/// be inferred from this pointer; the caller guarantees the entire native read.
#[doc(alias = "vkUpdateDescriptorSetWithTemplateKHR")]
#[doc = "\n\n[Khronos reference: `vkUpdateDescriptorSetWithTemplateKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkUpdateDescriptorSetWithTemplateKHR.html)"]
pub unsafe fn update_descriptor_set_with_template_khr(
	device: &Device,
	descriptor_set: vk::DescriptorSet,
	descriptor_update_template: vk::DescriptorUpdateTemplate,
	data: *const std::ffi::c_void,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.update_descriptor_set_with_template_khr
			.ok_or(CallError::MissingCommand(
				"vkUpdateDescriptorSetWithTemplateKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			descriptor_set,
			descriptor_update_template,
			data,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkUpdateDescriptorSetWithTemplateKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkUpdateDescriptorSetWithTemplateKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Data must address initialized descriptor payloads with the alignment, offsets,
	/// strides and extent declared by descriptor_update_template. No byte size can
	/// be inferred from this pointer; the caller guarantees the entire native read.
	#[doc(alias = "vkUpdateDescriptorSetWithTemplateKHR")]
	#[doc = "\n\n[Khronos reference: `vkUpdateDescriptorSetWithTemplateKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkUpdateDescriptorSetWithTemplateKHR.html)"]
	#[inline]
	pub unsafe fn update_descriptor_set_with_template_khr(
		&self,
		descriptor_set: vk::DescriptorSet,
		descriptor_update_template: vk::DescriptorUpdateTemplate,
		data: *const std::ffi::c_void,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			update_descriptor_set_with_template_khr(
				self,
				descriptor_set,
				descriptor_update_template,
				data,
			)
		}
	}
}

/// Call `vkCmdPushDescriptorSetWithTemplate` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdPushDescriptorSetWithTemplate` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdPushDescriptorSetWithTemplate")]
#[doc = "\n\n[Khronos reference: `vkCmdPushDescriptorSetWithTemplate`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushDescriptorSetWithTemplate.html)"]
pub unsafe fn cmd_push_descriptor_set_with_template(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	descriptor_update_template: vk::DescriptorUpdateTemplate,
	layout: vk::PipelineLayout,
	set: u32,
	p_data: *const std::ffi::c_void,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_push_descriptor_set_with_template
			.ok_or(CallError::MissingCommand(
				"vkCmdPushDescriptorSetWithTemplate",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			descriptor_update_template,
			layout,
			set,
			p_data,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdPushDescriptorSetWithTemplate` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdPushDescriptorSetWithTemplate` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdPushDescriptorSetWithTemplate")]
	#[doc = "\n\n[Khronos reference: `vkCmdPushDescriptorSetWithTemplate`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushDescriptorSetWithTemplate.html)"]
	#[inline]
	pub unsafe fn cmd_push_descriptor_set_with_template(
		&self,
		command_buffer: vk::CommandBuffer,
		descriptor_update_template: vk::DescriptorUpdateTemplate,
		layout: vk::PipelineLayout,
		set: u32,
		p_data: *const std::ffi::c_void,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_push_descriptor_set_with_template(
				self,
				command_buffer,
				descriptor_update_template,
				layout,
				set,
				p_data,
			)
		}
	}
}

/// Call `vkCmdPushDescriptorSetWithTemplateKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdPushDescriptorSetWithTemplateKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdPushDescriptorSetWithTemplateKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdPushDescriptorSetWithTemplateKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushDescriptorSetWithTemplateKHR.html)"]
pub unsafe fn cmd_push_descriptor_set_with_template_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	descriptor_update_template: vk::DescriptorUpdateTemplate,
	layout: vk::PipelineLayout,
	set: u32,
	p_data: *const std::ffi::c_void,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_push_descriptor_set_with_template_khr
		.ok_or(CallError::MissingCommand(
			"vkCmdPushDescriptorSetWithTemplateKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			descriptor_update_template,
			layout,
			set,
			p_data,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdPushDescriptorSetWithTemplateKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdPushDescriptorSetWithTemplateKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdPushDescriptorSetWithTemplateKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdPushDescriptorSetWithTemplateKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushDescriptorSetWithTemplateKHR.html)"]
	#[inline]
	pub unsafe fn cmd_push_descriptor_set_with_template_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		descriptor_update_template: vk::DescriptorUpdateTemplate,
		layout: vk::PipelineLayout,
		set: u32,
		p_data: *const std::ffi::c_void,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_push_descriptor_set_with_template_khr(
				self,
				command_buffer,
				descriptor_update_template,
				layout,
				set,
				p_data,
			)
		}
	}
}

/// Call `vkSetHdrMetadataEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkSetHdrMetadataEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkSetHdrMetadataEXT")]
#[doc = "\n\n[Khronos reference: `vkSetHdrMetadataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetHdrMetadataEXT.html)"]
pub unsafe fn set_hdr_metadata_ext(
	device: &Device,
	swapchain_count: u32,
	p_swapchains: *const vk::SwapchainKHR,
	p_metadata: *const vk::HdrMetadataEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.set_hdr_metadata_ext
		.ok_or(CallError::MissingCommand("vkSetHdrMetadataEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), swapchain_count, p_swapchains, p_metadata) };
	Ok(())
}

impl Device {
	/// Call `vkSetHdrMetadataEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkSetHdrMetadataEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkSetHdrMetadataEXT")]
	#[doc = "\n\n[Khronos reference: `vkSetHdrMetadataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetHdrMetadataEXT.html)"]
	#[inline]
	pub unsafe fn set_hdr_metadata_ext(
		&self,
		swapchain_count: u32,
		p_swapchains: *const vk::SwapchainKHR,
		p_metadata: *const vk::HdrMetadataEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { set_hdr_metadata_ext(self, swapchain_count, p_swapchains, p_metadata) }
	}
}

/// Call `vkGetSwapchainStatusKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetSwapchainStatusKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetSwapchainStatusKHR")]
#[doc = "\n\n[Khronos reference: `vkGetSwapchainStatusKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSwapchainStatusKHR.html)"]
pub unsafe fn get_swapchain_status_khr(
	device: &Device,
	swapchain: vk::SwapchainKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_swapchain_status_khr
		.ok_or(CallError::MissingCommand("vkGetSwapchainStatusKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), swapchain) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetSwapchainStatusKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetSwapchainStatusKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetSwapchainStatusKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetSwapchainStatusKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSwapchainStatusKHR.html)"]
	#[inline]
	pub unsafe fn get_swapchain_status_khr(
		&self,
		swapchain: vk::SwapchainKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_swapchain_status_khr(self, swapchain) }
	}
}

/// Call `vkGetRefreshCycleDurationGOOGLE` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetRefreshCycleDurationGOOGLE` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetRefreshCycleDurationGOOGLE")]
#[doc = "\n\n[Khronos reference: `vkGetRefreshCycleDurationGOOGLE`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetRefreshCycleDurationGOOGLE.html)"]
pub unsafe fn get_refresh_cycle_duration_google(
	device: &Device,
	swapchain: vk::SwapchainKHR,
	p_display_timing_properties: *mut vk::RefreshCycleDurationGOOGLE,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_refresh_cycle_duration_google
		.ok_or(CallError::MissingCommand("vkGetRefreshCycleDurationGOOGLE"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), swapchain, p_display_timing_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetRefreshCycleDurationGOOGLE` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetRefreshCycleDurationGOOGLE` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetRefreshCycleDurationGOOGLE")]
	#[doc = "\n\n[Khronos reference: `vkGetRefreshCycleDurationGOOGLE`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetRefreshCycleDurationGOOGLE.html)"]
	#[inline]
	pub unsafe fn get_refresh_cycle_duration_google(
		&self,
		swapchain: vk::SwapchainKHR,
		p_display_timing_properties: *mut vk::RefreshCycleDurationGOOGLE,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_refresh_cycle_duration_google(self, swapchain, p_display_timing_properties) }
	}
}

/// Call `vkGetPastPresentationTimingGOOGLE` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPastPresentationTimingGOOGLE` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPastPresentationTimingGOOGLE")]
#[doc = "\n\n[Khronos reference: `vkGetPastPresentationTimingGOOGLE`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPastPresentationTimingGOOGLE.html)"]
pub unsafe fn get_past_presentation_timing_google(
	device: &Device,
	swapchain: vk::SwapchainKHR,
	p_presentation_timing_count: *mut u32,
	p_presentation_timings: *mut vk::PastPresentationTimingGOOGLE,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.get_past_presentation_timing_google
			.ok_or(CallError::MissingCommand(
				"vkGetPastPresentationTimingGOOGLE",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			swapchain,
			p_presentation_timing_count,
			p_presentation_timings,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetPastPresentationTimingGOOGLE` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPastPresentationTimingGOOGLE` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPastPresentationTimingGOOGLE")]
	#[doc = "\n\n[Khronos reference: `vkGetPastPresentationTimingGOOGLE`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPastPresentationTimingGOOGLE.html)"]
	#[inline]
	pub unsafe fn get_past_presentation_timing_google(
		&self,
		swapchain: vk::SwapchainKHR,
		p_presentation_timing_count: *mut u32,
		p_presentation_timings: *mut vk::PastPresentationTimingGOOGLE,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_past_presentation_timing_google(
				self,
				swapchain,
				p_presentation_timing_count,
				p_presentation_timings,
			)
		}
	}
}

#[cfg(feature = "platform-ios")]
/// Call `vkCreateIOSSurfaceMVK` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateIOSSurfaceMVK` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateIOSSurfaceMVK")]
#[doc = "\n\n[Khronos reference: `vkCreateIOSSurfaceMVK`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateIOSSurfaceMVK.html)"]
pub unsafe fn create_ios_surface_mvk(
	instance: &Instance,
	p_create_info: *const vk::IOSSurfaceCreateInfoMVK<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_surface: *mut vk::SurfaceKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.create_ios_surface_mvk
		.ok_or(CallError::MissingCommand("vkCreateIOSSurfaceMVK"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), p_create_info, p_allocator, p_surface) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-ios")]
impl Instance {
	/// Call `vkCreateIOSSurfaceMVK` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateIOSSurfaceMVK` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateIOSSurfaceMVK")]
	#[doc = "\n\n[Khronos reference: `vkCreateIOSSurfaceMVK`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateIOSSurfaceMVK.html)"]
	#[inline]
	pub unsafe fn create_ios_surface_mvk(
		&self,
		p_create_info: *const vk::IOSSurfaceCreateInfoMVK<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_surface: *mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_ios_surface_mvk(self, p_create_info, p_allocator, p_surface) }
	}
}

#[cfg(feature = "platform-macos")]
/// Call `vkCreateMacOSSurfaceMVK` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateMacOSSurfaceMVK` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateMacOSSurfaceMVK")]
#[doc = "\n\n[Khronos reference: `vkCreateMacOSSurfaceMVK`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateMacOSSurfaceMVK.html)"]
pub unsafe fn create_mac_os_surface_mvk(
	instance: &Instance,
	p_create_info: *const vk::MacOSSurfaceCreateInfoMVK<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_surface: *mut vk::SurfaceKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.create_mac_os_surface_mvk
		.ok_or(CallError::MissingCommand("vkCreateMacOSSurfaceMVK"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), p_create_info, p_allocator, p_surface) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-macos")]
impl Instance {
	/// Call `vkCreateMacOSSurfaceMVK` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateMacOSSurfaceMVK` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateMacOSSurfaceMVK")]
	#[doc = "\n\n[Khronos reference: `vkCreateMacOSSurfaceMVK`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateMacOSSurfaceMVK.html)"]
	#[inline]
	pub unsafe fn create_mac_os_surface_mvk(
		&self,
		p_create_info: *const vk::MacOSSurfaceCreateInfoMVK<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_surface: *mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_mac_os_surface_mvk(self, p_create_info, p_allocator, p_surface) }
	}
}

#[cfg(feature = "platform-metal")]
/// Call `vkCreateMetalSurfaceEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateMetalSurfaceEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateMetalSurfaceEXT")]
#[doc = "\n\n[Khronos reference: `vkCreateMetalSurfaceEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateMetalSurfaceEXT.html)"]
pub unsafe fn create_metal_surface_ext(
	instance: &Instance,
	p_create_info: *const vk::MetalSurfaceCreateInfoEXT<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_surface: *mut vk::SurfaceKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.create_metal_surface_ext
		.ok_or(CallError::MissingCommand("vkCreateMetalSurfaceEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), p_create_info, p_allocator, p_surface) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-metal")]
impl Instance {
	/// Call `vkCreateMetalSurfaceEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateMetalSurfaceEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateMetalSurfaceEXT")]
	#[doc = "\n\n[Khronos reference: `vkCreateMetalSurfaceEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateMetalSurfaceEXT.html)"]
	#[inline]
	pub unsafe fn create_metal_surface_ext(
		&self,
		p_create_info: *const vk::MetalSurfaceCreateInfoEXT<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_surface: *mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_metal_surface_ext(self, p_create_info, p_allocator, p_surface) }
	}
}

/// Call `vkCmdSetViewportWScalingNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetViewportWScalingNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetViewportWScalingNV")]
#[doc = "\n\n[Khronos reference: `vkCmdSetViewportWScalingNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetViewportWScalingNV.html)"]
pub unsafe fn cmd_set_viewport_w_scaling_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_viewport: u32,
	viewport_count: u32,
	p_viewport_w_scalings: *const vk::ViewportWScalingNV,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_viewport_w_scaling_nv
		.ok_or(CallError::MissingCommand("vkCmdSetViewportWScalingNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_viewport,
			viewport_count,
			p_viewport_w_scalings,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdSetViewportWScalingNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetViewportWScalingNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetViewportWScalingNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetViewportWScalingNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetViewportWScalingNV.html)"]
	#[inline]
	pub unsafe fn cmd_set_viewport_w_scaling_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		first_viewport: u32,
		viewport_count: u32,
		p_viewport_w_scalings: *const vk::ViewportWScalingNV,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_viewport_w_scaling_nv(
				self,
				command_buffer,
				first_viewport,
				viewport_count,
				p_viewport_w_scalings,
			)
		}
	}
}

/// Call `vkCmdSetDiscardRectangleEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDiscardRectangleEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDiscardRectangleEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDiscardRectangleEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDiscardRectangleEXT.html)"]
pub unsafe fn cmd_set_discard_rectangle_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_discard_rectangle: u32,
	discard_rectangle_count: u32,
	p_discard_rectangles: *const vk::Rect2D,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_discard_rectangle_ext
		.ok_or(CallError::MissingCommand("vkCmdSetDiscardRectangleEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_discard_rectangle,
			discard_rectangle_count,
			p_discard_rectangles,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDiscardRectangleEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDiscardRectangleEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDiscardRectangleEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDiscardRectangleEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDiscardRectangleEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_discard_rectangle_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		first_discard_rectangle: u32,
		discard_rectangle_count: u32,
		p_discard_rectangles: *const vk::Rect2D,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_discard_rectangle_ext(
				self,
				command_buffer,
				first_discard_rectangle,
				discard_rectangle_count,
				p_discard_rectangles,
			)
		}
	}
}

/// Call `vkCmdSetDiscardRectangleEnableEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDiscardRectangleEnableEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDiscardRectangleEnableEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDiscardRectangleEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDiscardRectangleEnableEXT.html)"]
pub unsafe fn cmd_set_discard_rectangle_enable_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	discard_rectangle_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_discard_rectangle_enable_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdSetDiscardRectangleEnableEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, discard_rectangle_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDiscardRectangleEnableEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDiscardRectangleEnableEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDiscardRectangleEnableEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDiscardRectangleEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDiscardRectangleEnableEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_discard_rectangle_enable_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		discard_rectangle_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_discard_rectangle_enable_ext(self, command_buffer, discard_rectangle_enable) }
	}
}

/// Call `vkCmdSetDiscardRectangleModeEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDiscardRectangleModeEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDiscardRectangleModeEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDiscardRectangleModeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDiscardRectangleModeEXT.html)"]
pub unsafe fn cmd_set_discard_rectangle_mode_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	discard_rectangle_mode: vk::DiscardRectangleModeEXT,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_discard_rectangle_mode_ext
		.ok_or(CallError::MissingCommand("vkCmdSetDiscardRectangleModeEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, discard_rectangle_mode) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDiscardRectangleModeEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDiscardRectangleModeEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDiscardRectangleModeEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDiscardRectangleModeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDiscardRectangleModeEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_discard_rectangle_mode_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		discard_rectangle_mode: vk::DiscardRectangleModeEXT,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_discard_rectangle_mode_ext(self, command_buffer, discard_rectangle_mode) }
	}
}

/// Call `vkCmdSetSampleLocationsEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetSampleLocationsEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetSampleLocationsEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetSampleLocationsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetSampleLocationsEXT.html)"]
pub unsafe fn cmd_set_sample_locations_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_sample_locations_info: *const vk::SampleLocationsInfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_sample_locations_ext
		.ok_or(CallError::MissingCommand("vkCmdSetSampleLocationsEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_sample_locations_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetSampleLocationsEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetSampleLocationsEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetSampleLocationsEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetSampleLocationsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetSampleLocationsEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_sample_locations_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_sample_locations_info: *const vk::SampleLocationsInfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_sample_locations_ext(self, command_buffer, p_sample_locations_info) }
	}
}

/// Call `vkGetPhysicalDeviceMultisamplePropertiesEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceMultisamplePropertiesEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceMultisamplePropertiesEXT")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceMultisamplePropertiesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceMultisamplePropertiesEXT.html)"]
pub unsafe fn get_physical_device_multisample_properties_ext(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	samples: vk::SampleCountFlagBits,
	p_multisample_properties: *mut vk::MultisamplePropertiesEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_multisample_properties_ext
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceMultisamplePropertiesEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(physical_device, samples, p_multisample_properties) };
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceMultisamplePropertiesEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceMultisamplePropertiesEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceMultisamplePropertiesEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceMultisamplePropertiesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceMultisamplePropertiesEXT.html)"]
	#[inline]
	pub unsafe fn get_physical_device_multisample_properties_ext(
		&self,
		physical_device: vk::PhysicalDevice,
		samples: vk::SampleCountFlagBits,
		p_multisample_properties: *mut vk::MultisamplePropertiesEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_multisample_properties_ext(
				self,
				physical_device,
				samples,
				p_multisample_properties,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceSurfaceCapabilities2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceSurfaceCapabilities2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceSurfaceCapabilities2KHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSurfaceCapabilities2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html)"]
pub unsafe fn get_physical_device_surface_capabilities2_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_surface_info: *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
	p_surface_capabilities: *mut vk::SurfaceCapabilities2KHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_surface_capabilities2_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceSurfaceCapabilities2KHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, p_surface_info, p_surface_capabilities) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceSurfaceCapabilities2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceSurfaceCapabilities2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceSurfaceCapabilities2KHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSurfaceCapabilities2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_surface_capabilities2_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		p_surface_info: *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
		p_surface_capabilities: *mut vk::SurfaceCapabilities2KHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_surface_capabilities2_khr(
				self,
				physical_device,
				p_surface_info,
				p_surface_capabilities,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceSurfaceFormats2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceSurfaceFormats2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceSurfaceFormats2KHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSurfaceFormats2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSurfaceFormats2KHR.html)"]
pub unsafe fn get_physical_device_surface_formats2_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_surface_info: *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
	p_surface_format_count: *mut u32,
	p_surface_formats: *mut vk::SurfaceFormat2KHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_surface_formats2_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceSurfaceFormats2KHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			physical_device,
			p_surface_info,
			p_surface_format_count,
			p_surface_formats,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceSurfaceFormats2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceSurfaceFormats2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceSurfaceFormats2KHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSurfaceFormats2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSurfaceFormats2KHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_surface_formats2_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		p_surface_info: *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
		p_surface_format_count: *mut u32,
		p_surface_formats: *mut vk::SurfaceFormat2KHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_surface_formats2_khr(
				self,
				physical_device,
				p_surface_info,
				p_surface_format_count,
				p_surface_formats,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceDisplayProperties2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceDisplayProperties2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceDisplayProperties2KHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceDisplayProperties2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceDisplayProperties2KHR.html)"]
pub unsafe fn get_physical_device_display_properties2_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_property_count: *mut u32,
	p_properties: *mut vk::DisplayProperties2KHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_display_properties2_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceDisplayProperties2KHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, p_property_count, p_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceDisplayProperties2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceDisplayProperties2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceDisplayProperties2KHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceDisplayProperties2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceDisplayProperties2KHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_display_properties2_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		p_property_count: *mut u32,
		p_properties: *mut vk::DisplayProperties2KHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_display_properties2_khr(
				self,
				physical_device,
				p_property_count,
				p_properties,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceDisplayPlaneProperties2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceDisplayPlaneProperties2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceDisplayPlaneProperties2KHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceDisplayPlaneProperties2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html)"]
pub unsafe fn get_physical_device_display_plane_properties2_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_property_count: *mut u32,
	p_properties: *mut vk::DisplayPlaneProperties2KHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_display_plane_properties2_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceDisplayPlaneProperties2KHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, p_property_count, p_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceDisplayPlaneProperties2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceDisplayPlaneProperties2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceDisplayPlaneProperties2KHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceDisplayPlaneProperties2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_display_plane_properties2_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		p_property_count: *mut u32,
		p_properties: *mut vk::DisplayPlaneProperties2KHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_display_plane_properties2_khr(
				self,
				physical_device,
				p_property_count,
				p_properties,
			)
		}
	}
}

/// Call `vkGetDisplayModeProperties2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDisplayModeProperties2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDisplayModeProperties2KHR")]
#[doc = "\n\n[Khronos reference: `vkGetDisplayModeProperties2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDisplayModeProperties2KHR.html)"]
pub unsafe fn get_display_mode_properties2_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	display: vk::DisplayKHR,
	p_property_count: *mut u32,
	p_properties: *mut vk::DisplayModeProperties2KHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_display_mode_properties2_khr
		.ok_or(CallError::MissingCommand("vkGetDisplayModeProperties2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, display, p_property_count, p_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetDisplayModeProperties2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDisplayModeProperties2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDisplayModeProperties2KHR")]
	#[doc = "\n\n[Khronos reference: `vkGetDisplayModeProperties2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDisplayModeProperties2KHR.html)"]
	#[inline]
	pub unsafe fn get_display_mode_properties2_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		display: vk::DisplayKHR,
		p_property_count: *mut u32,
		p_properties: *mut vk::DisplayModeProperties2KHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_display_mode_properties2_khr(
				self,
				physical_device,
				display,
				p_property_count,
				p_properties,
			)
		}
	}
}

/// Call `vkGetDisplayPlaneCapabilities2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDisplayPlaneCapabilities2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDisplayPlaneCapabilities2KHR")]
#[doc = "\n\n[Khronos reference: `vkGetDisplayPlaneCapabilities2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDisplayPlaneCapabilities2KHR.html)"]
pub unsafe fn get_display_plane_capabilities2_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_display_plane_info: *const vk::DisplayPlaneInfo2KHR<'_>,
	p_capabilities: *mut vk::DisplayPlaneCapabilities2KHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		instance
			.fp()
			.get_display_plane_capabilities2_khr
			.ok_or(CallError::MissingCommand(
				"vkGetDisplayPlaneCapabilities2KHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, p_display_plane_info, p_capabilities) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetDisplayPlaneCapabilities2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDisplayPlaneCapabilities2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDisplayPlaneCapabilities2KHR")]
	#[doc = "\n\n[Khronos reference: `vkGetDisplayPlaneCapabilities2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDisplayPlaneCapabilities2KHR.html)"]
	#[inline]
	pub unsafe fn get_display_plane_capabilities2_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		p_display_plane_info: *const vk::DisplayPlaneInfo2KHR<'_>,
		p_capabilities: *mut vk::DisplayPlaneCapabilities2KHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_display_plane_capabilities2_khr(
				self,
				physical_device,
				p_display_plane_info,
				p_capabilities,
			)
		}
	}
}

/// Call `vkGetBufferMemoryRequirements2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetBufferMemoryRequirements2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetBufferMemoryRequirements2")]
#[doc = "\n\n[Khronos reference: `vkGetBufferMemoryRequirements2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetBufferMemoryRequirements2.html)"]
pub unsafe fn get_buffer_memory_requirements2(
	device: &Device,
	info: &vk::BufferMemoryRequirementsInfo2<'_>,
	memory_requirements: &mut vk::MemoryRequirements2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_buffer_memory_requirements2
		.ok_or(CallError::MissingCommand("vkGetBufferMemoryRequirements2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), info, memory_requirements) };
	Ok(())
}

impl Device {
	/// Call `vkGetBufferMemoryRequirements2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetBufferMemoryRequirements2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetBufferMemoryRequirements2")]
	#[doc = "\n\n[Khronos reference: `vkGetBufferMemoryRequirements2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetBufferMemoryRequirements2.html)"]
	#[inline]
	pub unsafe fn get_buffer_memory_requirements2(
		&self,
		info: &vk::BufferMemoryRequirementsInfo2<'_>,
		memory_requirements: &mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_buffer_memory_requirements2(self, info, memory_requirements) }
	}
}

/// Call `vkGetBufferMemoryRequirements2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetBufferMemoryRequirements2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetBufferMemoryRequirements2KHR")]
#[doc = "\n\n[Khronos reference: `vkGetBufferMemoryRequirements2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetBufferMemoryRequirements2KHR.html)"]
pub unsafe fn get_buffer_memory_requirements2_khr(
	device: &Device,
	info: &vk::BufferMemoryRequirementsInfo2<'_>,
	memory_requirements: &mut vk::MemoryRequirements2<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.get_buffer_memory_requirements2_khr
			.ok_or(CallError::MissingCommand(
				"vkGetBufferMemoryRequirements2KHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), info, memory_requirements) };
	Ok(())
}

impl Device {
	/// Call `vkGetBufferMemoryRequirements2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetBufferMemoryRequirements2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetBufferMemoryRequirements2KHR")]
	#[doc = "\n\n[Khronos reference: `vkGetBufferMemoryRequirements2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetBufferMemoryRequirements2KHR.html)"]
	#[inline]
	pub unsafe fn get_buffer_memory_requirements2_khr(
		&self,
		info: &vk::BufferMemoryRequirementsInfo2<'_>,
		memory_requirements: &mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_buffer_memory_requirements2_khr(self, info, memory_requirements) }
	}
}

/// Call `vkGetImageMemoryRequirements2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetImageMemoryRequirements2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetImageMemoryRequirements2")]
#[doc = "\n\n[Khronos reference: `vkGetImageMemoryRequirements2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageMemoryRequirements2.html)"]
pub unsafe fn get_image_memory_requirements2(
	device: &Device,
	info: &vk::ImageMemoryRequirementsInfo2<'_>,
	memory_requirements: &mut vk::MemoryRequirements2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_image_memory_requirements2
		.ok_or(CallError::MissingCommand("vkGetImageMemoryRequirements2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), info, memory_requirements) };
	Ok(())
}

impl Device {
	/// Call `vkGetImageMemoryRequirements2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetImageMemoryRequirements2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetImageMemoryRequirements2")]
	#[doc = "\n\n[Khronos reference: `vkGetImageMemoryRequirements2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageMemoryRequirements2.html)"]
	#[inline]
	pub unsafe fn get_image_memory_requirements2(
		&self,
		info: &vk::ImageMemoryRequirementsInfo2<'_>,
		memory_requirements: &mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_image_memory_requirements2(self, info, memory_requirements) }
	}
}

/// Call `vkGetImageMemoryRequirements2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetImageMemoryRequirements2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetImageMemoryRequirements2KHR")]
#[doc = "\n\n[Khronos reference: `vkGetImageMemoryRequirements2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageMemoryRequirements2KHR.html)"]
pub unsafe fn get_image_memory_requirements2_khr(
	device: &Device,
	info: &vk::ImageMemoryRequirementsInfo2<'_>,
	memory_requirements: &mut vk::MemoryRequirements2<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.get_image_memory_requirements2_khr
			.ok_or(CallError::MissingCommand(
				"vkGetImageMemoryRequirements2KHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), info, memory_requirements) };
	Ok(())
}

impl Device {
	/// Call `vkGetImageMemoryRequirements2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetImageMemoryRequirements2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetImageMemoryRequirements2KHR")]
	#[doc = "\n\n[Khronos reference: `vkGetImageMemoryRequirements2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageMemoryRequirements2KHR.html)"]
	#[inline]
	pub unsafe fn get_image_memory_requirements2_khr(
		&self,
		info: &vk::ImageMemoryRequirementsInfo2<'_>,
		memory_requirements: &mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_image_memory_requirements2_khr(self, info, memory_requirements) }
	}
}

/// Call `vkGetImageSparseMemoryRequirements2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetImageSparseMemoryRequirements2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Pass None to query the count, or Some with fully initialized output records
/// and live, valid output chains. The slice length supplies native capacity;
/// count receives the native number available/written. Some(empty) is a zero-
/// capacity fill, not a count query. No allocation, retry, header reset or chain
/// replacement occurs. Handle INCOMPLETE (result queries) or re-query for growth
/// (void queries) explicitly. Output contents after native errors follow Vulkan.
#[doc(alias = "vkGetImageSparseMemoryRequirements2")]
#[doc = "\n\n[Khronos reference: `vkGetImageSparseMemoryRequirements2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageSparseMemoryRequirements2.html)"]
pub unsafe fn get_image_sparse_memory_requirements2(
	device: &Device,
	info: &vk::ImageSparseMemoryRequirementsInfo2<'_>,
	sparse_memory_requirement_count: &mut u32,
	sparse_memory_requirements: Option<&mut [vk::SparseImageMemoryRequirements2<'_>]>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.get_image_sparse_memory_requirements2
			.ok_or(CallError::MissingCommand(
				"vkGetImageSparseMemoryRequirements2",
			))?;
	let capacity = sparse_memory_requirements
		.as_ref()
		.map(|values| values.len());
	if let Some(capacity) = capacity {
		*sparse_memory_requirement_count =
			u32::try_from(capacity).map_err(|_| CallError::CountOverflow(capacity))?;
	}
	let values =
		sparse_memory_requirements.map_or(std::ptr::null_mut(), |values| values.as_mut_ptr());
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			info,
			sparse_memory_requirement_count,
			values,
		)
	};
	if capacity.is_some_and(|capacity| u64::from(*sparse_memory_requirement_count) > capacity as u64)
	{
		return Err(CallError::InvalidOutput(
			"vkGetImageSparseMemoryRequirements2",
		));
	}
	Ok(())
}

impl Device {
	/// Call `vkGetImageSparseMemoryRequirements2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetImageSparseMemoryRequirements2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Pass None to query the count, or Some with fully initialized output records
	/// and live, valid output chains. The slice length supplies native capacity;
	/// count receives the native number available/written. Some(empty) is a zero-
	/// capacity fill, not a count query. No allocation, retry, header reset or chain
	/// replacement occurs. Handle INCOMPLETE (result queries) or re-query for growth
	/// (void queries) explicitly. Output contents after native errors follow Vulkan.
	#[doc(alias = "vkGetImageSparseMemoryRequirements2")]
	#[doc = "\n\n[Khronos reference: `vkGetImageSparseMemoryRequirements2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageSparseMemoryRequirements2.html)"]
	#[inline]
	pub unsafe fn get_image_sparse_memory_requirements2(
		&self,
		info: &vk::ImageSparseMemoryRequirementsInfo2<'_>,
		sparse_memory_requirement_count: &mut u32,
		sparse_memory_requirements: Option<&mut [vk::SparseImageMemoryRequirements2<'_>]>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_image_sparse_memory_requirements2(
				self,
				info,
				sparse_memory_requirement_count,
				sparse_memory_requirements,
			)
		}
	}
}

/// Call `vkGetImageSparseMemoryRequirements2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetImageSparseMemoryRequirements2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Pass None to query the count, or Some with fully initialized output records
/// and live, valid output chains. The slice length supplies native capacity;
/// count receives the native number available/written. Some(empty) is a zero-
/// capacity fill, not a count query. No allocation, retry, header reset or chain
/// replacement occurs. Handle INCOMPLETE (result queries) or re-query for growth
/// (void queries) explicitly. Output contents after native errors follow Vulkan.
#[doc(alias = "vkGetImageSparseMemoryRequirements2KHR")]
#[doc = "\n\n[Khronos reference: `vkGetImageSparseMemoryRequirements2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageSparseMemoryRequirements2KHR.html)"]
pub unsafe fn get_image_sparse_memory_requirements2_khr(
	device: &Device,
	info: &vk::ImageSparseMemoryRequirementsInfo2<'_>,
	sparse_memory_requirement_count: &mut u32,
	sparse_memory_requirements: Option<&mut [vk::SparseImageMemoryRequirements2<'_>]>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_image_sparse_memory_requirements2_khr
		.ok_or(CallError::MissingCommand(
			"vkGetImageSparseMemoryRequirements2KHR",
		))?;
	let capacity = sparse_memory_requirements
		.as_ref()
		.map(|values| values.len());
	if let Some(capacity) = capacity {
		*sparse_memory_requirement_count =
			u32::try_from(capacity).map_err(|_| CallError::CountOverflow(capacity))?;
	}
	let values =
		sparse_memory_requirements.map_or(std::ptr::null_mut(), |values| values.as_mut_ptr());
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			info,
			sparse_memory_requirement_count,
			values,
		)
	};
	if capacity.is_some_and(|capacity| u64::from(*sparse_memory_requirement_count) > capacity as u64)
	{
		return Err(CallError::InvalidOutput(
			"vkGetImageSparseMemoryRequirements2KHR",
		));
	}
	Ok(())
}

impl Device {
	/// Call `vkGetImageSparseMemoryRequirements2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetImageSparseMemoryRequirements2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Pass None to query the count, or Some with fully initialized output records
	/// and live, valid output chains. The slice length supplies native capacity;
	/// count receives the native number available/written. Some(empty) is a zero-
	/// capacity fill, not a count query. No allocation, retry, header reset or chain
	/// replacement occurs. Handle INCOMPLETE (result queries) or re-query for growth
	/// (void queries) explicitly. Output contents after native errors follow Vulkan.
	#[doc(alias = "vkGetImageSparseMemoryRequirements2KHR")]
	#[doc = "\n\n[Khronos reference: `vkGetImageSparseMemoryRequirements2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageSparseMemoryRequirements2KHR.html)"]
	#[inline]
	pub unsafe fn get_image_sparse_memory_requirements2_khr(
		&self,
		info: &vk::ImageSparseMemoryRequirementsInfo2<'_>,
		sparse_memory_requirement_count: &mut u32,
		sparse_memory_requirements: Option<&mut [vk::SparseImageMemoryRequirements2<'_>]>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_image_sparse_memory_requirements2_khr(
				self,
				info,
				sparse_memory_requirement_count,
				sparse_memory_requirements,
			)
		}
	}
}

/// Call `vkGetDeviceBufferMemoryRequirements` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceBufferMemoryRequirements` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeviceBufferMemoryRequirements")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceBufferMemoryRequirements`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceBufferMemoryRequirements.html)"]
pub unsafe fn get_device_buffer_memory_requirements(
	device: &Device,
	p_info: *const vk::DeviceBufferMemoryRequirements<'_>,
	p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.get_device_buffer_memory_requirements
			.ok_or(CallError::MissingCommand(
				"vkGetDeviceBufferMemoryRequirements",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_info, p_memory_requirements) };
	Ok(())
}

impl Device {
	/// Call `vkGetDeviceBufferMemoryRequirements` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceBufferMemoryRequirements` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeviceBufferMemoryRequirements")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceBufferMemoryRequirements`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceBufferMemoryRequirements.html)"]
	#[inline]
	pub unsafe fn get_device_buffer_memory_requirements(
		&self,
		p_info: *const vk::DeviceBufferMemoryRequirements<'_>,
		p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_device_buffer_memory_requirements(self, p_info, p_memory_requirements) }
	}
}

/// Call `vkGetDeviceBufferMemoryRequirementsKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceBufferMemoryRequirementsKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeviceBufferMemoryRequirementsKHR")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceBufferMemoryRequirementsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceBufferMemoryRequirementsKHR.html)"]
pub unsafe fn get_device_buffer_memory_requirements_khr(
	device: &Device,
	p_info: *const vk::DeviceBufferMemoryRequirements<'_>,
	p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_device_buffer_memory_requirements_khr
		.ok_or(CallError::MissingCommand(
			"vkGetDeviceBufferMemoryRequirementsKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_info, p_memory_requirements) };
	Ok(())
}

impl Device {
	/// Call `vkGetDeviceBufferMemoryRequirementsKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceBufferMemoryRequirementsKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeviceBufferMemoryRequirementsKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceBufferMemoryRequirementsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceBufferMemoryRequirementsKHR.html)"]
	#[inline]
	pub unsafe fn get_device_buffer_memory_requirements_khr(
		&self,
		p_info: *const vk::DeviceBufferMemoryRequirements<'_>,
		p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_device_buffer_memory_requirements_khr(self, p_info, p_memory_requirements) }
	}
}

/// Call `vkGetDeviceImageMemoryRequirements` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceImageMemoryRequirements` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeviceImageMemoryRequirements")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceImageMemoryRequirements`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceImageMemoryRequirements.html)"]
pub unsafe fn get_device_image_memory_requirements(
	device: &Device,
	p_info: *const vk::DeviceImageMemoryRequirements<'_>,
	p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.get_device_image_memory_requirements
			.ok_or(CallError::MissingCommand(
				"vkGetDeviceImageMemoryRequirements",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_info, p_memory_requirements) };
	Ok(())
}

impl Device {
	/// Call `vkGetDeviceImageMemoryRequirements` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceImageMemoryRequirements` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeviceImageMemoryRequirements")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceImageMemoryRequirements`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceImageMemoryRequirements.html)"]
	#[inline]
	pub unsafe fn get_device_image_memory_requirements(
		&self,
		p_info: *const vk::DeviceImageMemoryRequirements<'_>,
		p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_device_image_memory_requirements(self, p_info, p_memory_requirements) }
	}
}

/// Call `vkGetDeviceImageMemoryRequirementsKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceImageMemoryRequirementsKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeviceImageMemoryRequirementsKHR")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceImageMemoryRequirementsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceImageMemoryRequirementsKHR.html)"]
pub unsafe fn get_device_image_memory_requirements_khr(
	device: &Device,
	p_info: *const vk::DeviceImageMemoryRequirements<'_>,
	p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.get_device_image_memory_requirements_khr
			.ok_or(CallError::MissingCommand(
				"vkGetDeviceImageMemoryRequirementsKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_info, p_memory_requirements) };
	Ok(())
}

impl Device {
	/// Call `vkGetDeviceImageMemoryRequirementsKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceImageMemoryRequirementsKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeviceImageMemoryRequirementsKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceImageMemoryRequirementsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceImageMemoryRequirementsKHR.html)"]
	#[inline]
	pub unsafe fn get_device_image_memory_requirements_khr(
		&self,
		p_info: *const vk::DeviceImageMemoryRequirements<'_>,
		p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_device_image_memory_requirements_khr(self, p_info, p_memory_requirements) }
	}
}

/// Call `vkGetDeviceImageSparseMemoryRequirements` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceImageSparseMemoryRequirements` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeviceImageSparseMemoryRequirements")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceImageSparseMemoryRequirements`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceImageSparseMemoryRequirements.html)"]
pub unsafe fn get_device_image_sparse_memory_requirements(
	device: &Device,
	p_info: *const vk::DeviceImageMemoryRequirements<'_>,
	p_sparse_memory_requirement_count: *mut u32,
	p_sparse_memory_requirements: *mut vk::SparseImageMemoryRequirements2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_device_image_sparse_memory_requirements
		.ok_or(CallError::MissingCommand(
			"vkGetDeviceImageSparseMemoryRequirements",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			p_info,
			p_sparse_memory_requirement_count,
			p_sparse_memory_requirements,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkGetDeviceImageSparseMemoryRequirements` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceImageSparseMemoryRequirements` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeviceImageSparseMemoryRequirements")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceImageSparseMemoryRequirements`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceImageSparseMemoryRequirements.html)"]
	#[inline]
	pub unsafe fn get_device_image_sparse_memory_requirements(
		&self,
		p_info: *const vk::DeviceImageMemoryRequirements<'_>,
		p_sparse_memory_requirement_count: *mut u32,
		p_sparse_memory_requirements: *mut vk::SparseImageMemoryRequirements2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_device_image_sparse_memory_requirements(
				self,
				p_info,
				p_sparse_memory_requirement_count,
				p_sparse_memory_requirements,
			)
		}
	}
}

/// Call `vkGetDeviceImageSparseMemoryRequirementsKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceImageSparseMemoryRequirementsKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeviceImageSparseMemoryRequirementsKHR")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceImageSparseMemoryRequirementsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceImageSparseMemoryRequirementsKHR.html)"]
pub unsafe fn get_device_image_sparse_memory_requirements_khr(
	device: &Device,
	p_info: *const vk::DeviceImageMemoryRequirements<'_>,
	p_sparse_memory_requirement_count: *mut u32,
	p_sparse_memory_requirements: *mut vk::SparseImageMemoryRequirements2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_device_image_sparse_memory_requirements_khr
		.ok_or(CallError::MissingCommand(
			"vkGetDeviceImageSparseMemoryRequirementsKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			p_info,
			p_sparse_memory_requirement_count,
			p_sparse_memory_requirements,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkGetDeviceImageSparseMemoryRequirementsKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceImageSparseMemoryRequirementsKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeviceImageSparseMemoryRequirementsKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceImageSparseMemoryRequirementsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceImageSparseMemoryRequirementsKHR.html)"]
	#[inline]
	pub unsafe fn get_device_image_sparse_memory_requirements_khr(
		&self,
		p_info: *const vk::DeviceImageMemoryRequirements<'_>,
		p_sparse_memory_requirement_count: *mut u32,
		p_sparse_memory_requirements: *mut vk::SparseImageMemoryRequirements2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_device_image_sparse_memory_requirements_khr(
				self,
				p_info,
				p_sparse_memory_requirement_count,
				p_sparse_memory_requirements,
			)
		}
	}
}

/// Call `vkCreateSamplerYcbcrConversion` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateSamplerYcbcrConversion` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCreateSamplerYcbcrConversion")]
#[doc = "\n\n[Khronos reference: `vkCreateSamplerYcbcrConversion`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateSamplerYcbcrConversion.html)"]
pub unsafe fn create_sampler_ycbcr_conversion(
	device: &Device,
	create_info: &vk::SamplerYcbcrConversionCreateInfo<'_>,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<vk::SamplerYcbcrConversion, CallError> {
	let __vk_function = device
		.fp()
		.create_sampler_ycbcr_conversion
		.ok_or(CallError::MissingCommand("vkCreateSamplerYcbcrConversion"))?;
	let mut output = vk::SamplerYcbcrConversion::NULL;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info,
			allocator.map_or(std::ptr::null(), |value| value),
			&mut output,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(output)
}

impl Device {
	/// Call `vkCreateSamplerYcbcrConversion` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateSamplerYcbcrConversion` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCreateSamplerYcbcrConversion")]
	#[doc = "\n\n[Khronos reference: `vkCreateSamplerYcbcrConversion`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateSamplerYcbcrConversion.html)"]
	#[inline]
	pub unsafe fn create_sampler_ycbcr_conversion(
		&self,
		create_info: &vk::SamplerYcbcrConversionCreateInfo<'_>,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<vk::SamplerYcbcrConversion, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_sampler_ycbcr_conversion(self, create_info, allocator) }
	}
}

/// Call `vkCreateSamplerYcbcrConversionKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateSamplerYcbcrConversionKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCreateSamplerYcbcrConversionKHR")]
#[doc = "\n\n[Khronos reference: `vkCreateSamplerYcbcrConversionKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateSamplerYcbcrConversionKHR.html)"]
pub unsafe fn create_sampler_ycbcr_conversion_khr(
	device: &Device,
	create_info: &vk::SamplerYcbcrConversionCreateInfo<'_>,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<vk::SamplerYcbcrConversion, CallError> {
	let __vk_function =
		device
			.fp()
			.create_sampler_ycbcr_conversion_khr
			.ok_or(CallError::MissingCommand(
				"vkCreateSamplerYcbcrConversionKHR",
			))?;
	let mut output = vk::SamplerYcbcrConversion::NULL;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info,
			allocator.map_or(std::ptr::null(), |value| value),
			&mut output,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(output)
}

impl Device {
	/// Call `vkCreateSamplerYcbcrConversionKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateSamplerYcbcrConversionKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCreateSamplerYcbcrConversionKHR")]
	#[doc = "\n\n[Khronos reference: `vkCreateSamplerYcbcrConversionKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateSamplerYcbcrConversionKHR.html)"]
	#[inline]
	pub unsafe fn create_sampler_ycbcr_conversion_khr(
		&self,
		create_info: &vk::SamplerYcbcrConversionCreateInfo<'_>,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<vk::SamplerYcbcrConversion, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_sampler_ycbcr_conversion_khr(self, create_info, allocator) }
	}
}

/// Call `vkDestroySamplerYcbcrConversion` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroySamplerYcbcrConversion` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkDestroySamplerYcbcrConversion")]
#[doc = "\n\n[Khronos reference: `vkDestroySamplerYcbcrConversion`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroySamplerYcbcrConversion.html)"]
pub unsafe fn destroy_sampler_ycbcr_conversion(
	device: &Device,
	ycbcr_conversion: vk::SamplerYcbcrConversion,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_sampler_ycbcr_conversion
		.ok_or(CallError::MissingCommand("vkDestroySamplerYcbcrConversion"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			ycbcr_conversion,
			allocator.map_or(std::ptr::null(), |value| value),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkDestroySamplerYcbcrConversion` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroySamplerYcbcrConversion` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkDestroySamplerYcbcrConversion")]
	#[doc = "\n\n[Khronos reference: `vkDestroySamplerYcbcrConversion`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroySamplerYcbcrConversion.html)"]
	#[inline]
	pub unsafe fn destroy_sampler_ycbcr_conversion(
		&self,
		ycbcr_conversion: vk::SamplerYcbcrConversion,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_sampler_ycbcr_conversion(self, ycbcr_conversion, allocator) }
	}
}

/// Call `vkDestroySamplerYcbcrConversionKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroySamplerYcbcrConversionKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkDestroySamplerYcbcrConversionKHR")]
#[doc = "\n\n[Khronos reference: `vkDestroySamplerYcbcrConversionKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroySamplerYcbcrConversionKHR.html)"]
pub unsafe fn destroy_sampler_ycbcr_conversion_khr(
	device: &Device,
	ycbcr_conversion: vk::SamplerYcbcrConversion,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.destroy_sampler_ycbcr_conversion_khr
			.ok_or(CallError::MissingCommand(
				"vkDestroySamplerYcbcrConversionKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			ycbcr_conversion,
			allocator.map_or(std::ptr::null(), |value| value),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkDestroySamplerYcbcrConversionKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroySamplerYcbcrConversionKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkDestroySamplerYcbcrConversionKHR")]
	#[doc = "\n\n[Khronos reference: `vkDestroySamplerYcbcrConversionKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroySamplerYcbcrConversionKHR.html)"]
	#[inline]
	pub unsafe fn destroy_sampler_ycbcr_conversion_khr(
		&self,
		ycbcr_conversion: vk::SamplerYcbcrConversion,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_sampler_ycbcr_conversion_khr(self, ycbcr_conversion, allocator) }
	}
}

/// Call `vkGetDeviceQueue2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceQueue2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetDeviceQueue2")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceQueue2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceQueue2.html)"]
pub unsafe fn get_device_queue2(
	device: &Device,
	queue_info: &vk::DeviceQueueInfo2<'_>,
	queue: &mut vk::Queue,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_device_queue2
		.ok_or(CallError::MissingCommand("vkGetDeviceQueue2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), queue_info, queue) };
	Ok(())
}

impl Device {
	/// Call `vkGetDeviceQueue2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceQueue2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetDeviceQueue2")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceQueue2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceQueue2.html)"]
	#[inline]
	pub unsafe fn get_device_queue2(
		&self,
		queue_info: &vk::DeviceQueueInfo2<'_>,
		queue: &mut vk::Queue,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_device_queue2(self, queue_info, queue) }
	}
}

/// Call `vkCreateValidationCacheEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateValidationCacheEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateValidationCacheEXT")]
#[doc = "\n\n[Khronos reference: `vkCreateValidationCacheEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateValidationCacheEXT.html)"]
pub unsafe fn create_validation_cache_ext(
	device: &Device,
	p_create_info: *const vk::ValidationCacheCreateInfoEXT<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_validation_cache: *mut vk::ValidationCacheEXT,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_validation_cache_ext
		.ok_or(CallError::MissingCommand("vkCreateValidationCacheEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_create_info,
			p_allocator,
			p_validation_cache,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateValidationCacheEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateValidationCacheEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateValidationCacheEXT")]
	#[doc = "\n\n[Khronos reference: `vkCreateValidationCacheEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateValidationCacheEXT.html)"]
	#[inline]
	pub unsafe fn create_validation_cache_ext(
		&self,
		p_create_info: *const vk::ValidationCacheCreateInfoEXT<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_validation_cache: *mut vk::ValidationCacheEXT,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_validation_cache_ext(self, p_create_info, p_allocator, p_validation_cache) }
	}
}

/// Call `vkDestroyValidationCacheEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyValidationCacheEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyValidationCacheEXT")]
#[doc = "\n\n[Khronos reference: `vkDestroyValidationCacheEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyValidationCacheEXT.html)"]
pub unsafe fn destroy_validation_cache_ext(
	device: &Device,
	validation_cache: vk::ValidationCacheEXT,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_validation_cache_ext
		.ok_or(CallError::MissingCommand("vkDestroyValidationCacheEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), validation_cache, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyValidationCacheEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyValidationCacheEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyValidationCacheEXT")]
	#[doc = "\n\n[Khronos reference: `vkDestroyValidationCacheEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyValidationCacheEXT.html)"]
	#[inline]
	pub unsafe fn destroy_validation_cache_ext(
		&self,
		validation_cache: vk::ValidationCacheEXT,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_validation_cache_ext(self, validation_cache, p_allocator) }
	}
}

/// Call `vkGetValidationCacheDataEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetValidationCacheDataEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetValidationCacheDataEXT")]
#[doc = "\n\n[Khronos reference: `vkGetValidationCacheDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetValidationCacheDataEXT.html)"]
pub unsafe fn get_validation_cache_data_ext(
	device: &Device,
	validation_cache: vk::ValidationCacheEXT,
	p_data_size: *mut usize,
	p_data: *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_validation_cache_data_ext
		.ok_or(CallError::MissingCommand("vkGetValidationCacheDataEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), validation_cache, p_data_size, p_data) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetValidationCacheDataEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetValidationCacheDataEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetValidationCacheDataEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetValidationCacheDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetValidationCacheDataEXT.html)"]
	#[inline]
	pub unsafe fn get_validation_cache_data_ext(
		&self,
		validation_cache: vk::ValidationCacheEXT,
		p_data_size: *mut usize,
		p_data: *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_validation_cache_data_ext(self, validation_cache, p_data_size, p_data) }
	}
}

/// Call `vkMergeValidationCachesEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkMergeValidationCachesEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkMergeValidationCachesEXT")]
#[doc = "\n\n[Khronos reference: `vkMergeValidationCachesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkMergeValidationCachesEXT.html)"]
pub unsafe fn merge_validation_caches_ext(
	device: &Device,
	dst_cache: vk::ValidationCacheEXT,
	src_cache_count: u32,
	p_src_caches: *const vk::ValidationCacheEXT,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.merge_validation_caches_ext
		.ok_or(CallError::MissingCommand("vkMergeValidationCachesEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), dst_cache, src_cache_count, p_src_caches) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkMergeValidationCachesEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkMergeValidationCachesEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkMergeValidationCachesEXT")]
	#[doc = "\n\n[Khronos reference: `vkMergeValidationCachesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkMergeValidationCachesEXT.html)"]
	#[inline]
	pub unsafe fn merge_validation_caches_ext(
		&self,
		dst_cache: vk::ValidationCacheEXT,
		src_cache_count: u32,
		p_src_caches: *const vk::ValidationCacheEXT,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { merge_validation_caches_ext(self, dst_cache, src_cache_count, p_src_caches) }
	}
}

/// Call `vkGetDescriptorSetLayoutSupport` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDescriptorSetLayoutSupport` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetDescriptorSetLayoutSupport")]
#[doc = "\n\n[Khronos reference: `vkGetDescriptorSetLayoutSupport`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDescriptorSetLayoutSupport.html)"]
pub unsafe fn get_descriptor_set_layout_support(
	device: &Device,
	create_info: &vk::DescriptorSetLayoutCreateInfo<'_>,
	support: &mut vk::DescriptorSetLayoutSupport<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_descriptor_set_layout_support
		.ok_or(CallError::MissingCommand("vkGetDescriptorSetLayoutSupport"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), create_info, support) };
	Ok(())
}

impl Device {
	/// Call `vkGetDescriptorSetLayoutSupport` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDescriptorSetLayoutSupport` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetDescriptorSetLayoutSupport")]
	#[doc = "\n\n[Khronos reference: `vkGetDescriptorSetLayoutSupport`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDescriptorSetLayoutSupport.html)"]
	#[inline]
	pub unsafe fn get_descriptor_set_layout_support(
		&self,
		create_info: &vk::DescriptorSetLayoutCreateInfo<'_>,
		support: &mut vk::DescriptorSetLayoutSupport<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_descriptor_set_layout_support(self, create_info, support) }
	}
}

/// Call `vkGetDescriptorSetLayoutSupportKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDescriptorSetLayoutSupportKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetDescriptorSetLayoutSupportKHR")]
#[doc = "\n\n[Khronos reference: `vkGetDescriptorSetLayoutSupportKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDescriptorSetLayoutSupportKHR.html)"]
pub unsafe fn get_descriptor_set_layout_support_khr(
	device: &Device,
	create_info: &vk::DescriptorSetLayoutCreateInfo<'_>,
	support: &mut vk::DescriptorSetLayoutSupport<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.get_descriptor_set_layout_support_khr
			.ok_or(CallError::MissingCommand(
				"vkGetDescriptorSetLayoutSupportKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), create_info, support) };
	Ok(())
}

impl Device {
	/// Call `vkGetDescriptorSetLayoutSupportKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDescriptorSetLayoutSupportKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetDescriptorSetLayoutSupportKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetDescriptorSetLayoutSupportKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDescriptorSetLayoutSupportKHR.html)"]
	#[inline]
	pub unsafe fn get_descriptor_set_layout_support_khr(
		&self,
		create_info: &vk::DescriptorSetLayoutCreateInfo<'_>,
		support: &mut vk::DescriptorSetLayoutSupport<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_descriptor_set_layout_support_khr(self, create_info, support) }
	}
}

/// Call `vkGetShaderInfoAMD` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetShaderInfoAMD` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetShaderInfoAMD")]
#[doc = "\n\n[Khronos reference: `vkGetShaderInfoAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetShaderInfoAMD.html)"]
pub unsafe fn get_shader_info_amd(
	device: &Device,
	pipeline: vk::Pipeline,
	shader_stage: vk::ShaderStageFlagBits,
	info_type: vk::ShaderInfoTypeAMD,
	p_info_size: *mut usize,
	p_info: *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_shader_info_amd
		.ok_or(CallError::MissingCommand("vkGetShaderInfoAMD"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			pipeline,
			shader_stage,
			info_type,
			p_info_size,
			p_info,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetShaderInfoAMD` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetShaderInfoAMD` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetShaderInfoAMD")]
	#[doc = "\n\n[Khronos reference: `vkGetShaderInfoAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetShaderInfoAMD.html)"]
	#[inline]
	pub unsafe fn get_shader_info_amd(
		&self,
		pipeline: vk::Pipeline,
		shader_stage: vk::ShaderStageFlagBits,
		info_type: vk::ShaderInfoTypeAMD,
		p_info_size: *mut usize,
		p_info: *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_shader_info_amd(self, pipeline, shader_stage, info_type, p_info_size, p_info) }
	}
}

/// Call `vkSetLocalDimmingAMD` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkSetLocalDimmingAMD` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkSetLocalDimmingAMD")]
#[doc = "\n\n[Khronos reference: `vkSetLocalDimmingAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetLocalDimmingAMD.html)"]
pub unsafe fn set_local_dimming_amd(
	device: &Device,
	swap_chain: vk::SwapchainKHR,
	local_dimming_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.set_local_dimming_amd
		.ok_or(CallError::MissingCommand("vkSetLocalDimmingAMD"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), swap_chain, local_dimming_enable) };
	Ok(())
}

impl Device {
	/// Call `vkSetLocalDimmingAMD` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkSetLocalDimmingAMD` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkSetLocalDimmingAMD")]
	#[doc = "\n\n[Khronos reference: `vkSetLocalDimmingAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetLocalDimmingAMD.html)"]
	#[inline]
	pub unsafe fn set_local_dimming_amd(
		&self,
		swap_chain: vk::SwapchainKHR,
		local_dimming_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { set_local_dimming_amd(self, swap_chain, local_dimming_enable) }
	}
}

/// Call `vkGetPhysicalDeviceCalibrateableTimeDomainsKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceCalibrateableTimeDomainsKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceCalibrateableTimeDomainsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html)"]
pub unsafe fn get_physical_device_calibrateable_time_domains_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_time_domain_count: *mut u32,
	p_time_domains: *mut vk::TimeDomainKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_calibrateable_time_domains_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceCalibrateableTimeDomainsKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, p_time_domain_count, p_time_domains) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceCalibrateableTimeDomainsKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceCalibrateableTimeDomainsKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceCalibrateableTimeDomainsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_calibrateable_time_domains_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		p_time_domain_count: *mut u32,
		p_time_domains: *mut vk::TimeDomainKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_calibrateable_time_domains_khr(
				self,
				physical_device,
				p_time_domain_count,
				p_time_domains,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceCalibrateableTimeDomainsEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceCalibrateableTimeDomainsEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceCalibrateableTimeDomainsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html)"]
pub unsafe fn get_physical_device_calibrateable_time_domains_ext(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_time_domain_count: *mut u32,
	p_time_domains: *mut vk::TimeDomainKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_calibrateable_time_domains_ext
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, p_time_domain_count, p_time_domains) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceCalibrateableTimeDomainsEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceCalibrateableTimeDomainsEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceCalibrateableTimeDomainsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html)"]
	#[inline]
	pub unsafe fn get_physical_device_calibrateable_time_domains_ext(
		&self,
		physical_device: vk::PhysicalDevice,
		p_time_domain_count: *mut u32,
		p_time_domains: *mut vk::TimeDomainKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_calibrateable_time_domains_ext(
				self,
				physical_device,
				p_time_domain_count,
				p_time_domains,
			)
		}
	}
}

/// Call `vkGetCalibratedTimestampsKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetCalibratedTimestampsKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetCalibratedTimestampsKHR")]
#[doc = "\n\n[Khronos reference: `vkGetCalibratedTimestampsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetCalibratedTimestampsKHR.html)"]
pub unsafe fn get_calibrated_timestamps_khr(
	device: &Device,
	timestamp_count: u32,
	p_timestamp_infos: *const vk::CalibratedTimestampInfoKHR<'_>,
	p_timestamps: *mut u64,
	p_max_deviation: *mut u64,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_calibrated_timestamps_khr
		.ok_or(CallError::MissingCommand("vkGetCalibratedTimestampsKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			timestamp_count,
			p_timestamp_infos,
			p_timestamps,
			p_max_deviation,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetCalibratedTimestampsKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetCalibratedTimestampsKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetCalibratedTimestampsKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetCalibratedTimestampsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetCalibratedTimestampsKHR.html)"]
	#[inline]
	pub unsafe fn get_calibrated_timestamps_khr(
		&self,
		timestamp_count: u32,
		p_timestamp_infos: *const vk::CalibratedTimestampInfoKHR<'_>,
		p_timestamps: *mut u64,
		p_max_deviation: *mut u64,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_calibrated_timestamps_khr(
				self,
				timestamp_count,
				p_timestamp_infos,
				p_timestamps,
				p_max_deviation,
			)
		}
	}
}

/// Call `vkGetCalibratedTimestampsEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetCalibratedTimestampsEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetCalibratedTimestampsEXT")]
#[doc = "\n\n[Khronos reference: `vkGetCalibratedTimestampsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetCalibratedTimestampsEXT.html)"]
pub unsafe fn get_calibrated_timestamps_ext(
	device: &Device,
	timestamp_count: u32,
	p_timestamp_infos: *const vk::CalibratedTimestampInfoKHR<'_>,
	p_timestamps: *mut u64,
	p_max_deviation: *mut u64,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_calibrated_timestamps_ext
		.ok_or(CallError::MissingCommand("vkGetCalibratedTimestampsEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			timestamp_count,
			p_timestamp_infos,
			p_timestamps,
			p_max_deviation,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetCalibratedTimestampsEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetCalibratedTimestampsEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetCalibratedTimestampsEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetCalibratedTimestampsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetCalibratedTimestampsEXT.html)"]
	#[inline]
	pub unsafe fn get_calibrated_timestamps_ext(
		&self,
		timestamp_count: u32,
		p_timestamp_infos: *const vk::CalibratedTimestampInfoKHR<'_>,
		p_timestamps: *mut u64,
		p_max_deviation: *mut u64,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_calibrated_timestamps_ext(
				self,
				timestamp_count,
				p_timestamp_infos,
				p_timestamps,
				p_max_deviation,
			)
		}
	}
}

/// Call `vkSetDebugUtilsObjectNameEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkSetDebugUtilsObjectNameEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkSetDebugUtilsObjectNameEXT")]
#[doc = "\n\n[Khronos reference: `vkSetDebugUtilsObjectNameEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetDebugUtilsObjectNameEXT.html)"]
pub unsafe fn set_debug_utils_object_name_ext(
	device: &Device,
	p_name_info: *const vk::DebugUtilsObjectNameInfoEXT<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.set_debug_utils_object_name_ext
		.ok_or(CallError::MissingCommand("vkSetDebugUtilsObjectNameEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_name_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkSetDebugUtilsObjectNameEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkSetDebugUtilsObjectNameEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkSetDebugUtilsObjectNameEXT")]
	#[doc = "\n\n[Khronos reference: `vkSetDebugUtilsObjectNameEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetDebugUtilsObjectNameEXT.html)"]
	#[inline]
	pub unsafe fn set_debug_utils_object_name_ext(
		&self,
		p_name_info: *const vk::DebugUtilsObjectNameInfoEXT<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { set_debug_utils_object_name_ext(self, p_name_info) }
	}
}

/// Call `vkSetDebugUtilsObjectTagEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkSetDebugUtilsObjectTagEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkSetDebugUtilsObjectTagEXT")]
#[doc = "\n\n[Khronos reference: `vkSetDebugUtilsObjectTagEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetDebugUtilsObjectTagEXT.html)"]
pub unsafe fn set_debug_utils_object_tag_ext(
	device: &Device,
	p_tag_info: *const vk::DebugUtilsObjectTagInfoEXT<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.set_debug_utils_object_tag_ext
		.ok_or(CallError::MissingCommand("vkSetDebugUtilsObjectTagEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_tag_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkSetDebugUtilsObjectTagEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkSetDebugUtilsObjectTagEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkSetDebugUtilsObjectTagEXT")]
	#[doc = "\n\n[Khronos reference: `vkSetDebugUtilsObjectTagEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetDebugUtilsObjectTagEXT.html)"]
	#[inline]
	pub unsafe fn set_debug_utils_object_tag_ext(
		&self,
		p_tag_info: *const vk::DebugUtilsObjectTagInfoEXT<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { set_debug_utils_object_tag_ext(self, p_tag_info) }
	}
}

/// Call `vkQueueBeginDebugUtilsLabelEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkQueueBeginDebugUtilsLabelEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkQueueBeginDebugUtilsLabelEXT")]
#[doc = "\n\n[Khronos reference: `vkQueueBeginDebugUtilsLabelEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueueBeginDebugUtilsLabelEXT.html)"]
pub unsafe fn queue_begin_debug_utils_label_ext(
	device: &Device,
	queue: vk::Queue,
	p_label_info: *const vk::DebugUtilsLabelEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.queue_begin_debug_utils_label_ext
		.ok_or(CallError::MissingCommand("vkQueueBeginDebugUtilsLabelEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(queue, p_label_info) };
	Ok(())
}

impl Device {
	/// Call `vkQueueBeginDebugUtilsLabelEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkQueueBeginDebugUtilsLabelEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkQueueBeginDebugUtilsLabelEXT")]
	#[doc = "\n\n[Khronos reference: `vkQueueBeginDebugUtilsLabelEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueueBeginDebugUtilsLabelEXT.html)"]
	#[inline]
	pub unsafe fn queue_begin_debug_utils_label_ext(
		&self,
		queue: vk::Queue,
		p_label_info: *const vk::DebugUtilsLabelEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { queue_begin_debug_utils_label_ext(self, queue, p_label_info) }
	}
}

/// Call `vkQueueEndDebugUtilsLabelEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkQueueEndDebugUtilsLabelEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkQueueEndDebugUtilsLabelEXT")]
#[doc = "\n\n[Khronos reference: `vkQueueEndDebugUtilsLabelEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueueEndDebugUtilsLabelEXT.html)"]
pub unsafe fn queue_end_debug_utils_label_ext(
	device: &Device,
	queue: vk::Queue,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.queue_end_debug_utils_label_ext
		.ok_or(CallError::MissingCommand("vkQueueEndDebugUtilsLabelEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(queue) };
	Ok(())
}

impl Device {
	/// Call `vkQueueEndDebugUtilsLabelEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkQueueEndDebugUtilsLabelEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkQueueEndDebugUtilsLabelEXT")]
	#[doc = "\n\n[Khronos reference: `vkQueueEndDebugUtilsLabelEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueueEndDebugUtilsLabelEXT.html)"]
	#[inline]
	pub unsafe fn queue_end_debug_utils_label_ext(&self, queue: vk::Queue) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { queue_end_debug_utils_label_ext(self, queue) }
	}
}

/// Call `vkQueueInsertDebugUtilsLabelEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkQueueInsertDebugUtilsLabelEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkQueueInsertDebugUtilsLabelEXT")]
#[doc = "\n\n[Khronos reference: `vkQueueInsertDebugUtilsLabelEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueueInsertDebugUtilsLabelEXT.html)"]
pub unsafe fn queue_insert_debug_utils_label_ext(
	device: &Device,
	queue: vk::Queue,
	p_label_info: *const vk::DebugUtilsLabelEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.queue_insert_debug_utils_label_ext
		.ok_or(CallError::MissingCommand("vkQueueInsertDebugUtilsLabelEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(queue, p_label_info) };
	Ok(())
}

impl Device {
	/// Call `vkQueueInsertDebugUtilsLabelEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkQueueInsertDebugUtilsLabelEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkQueueInsertDebugUtilsLabelEXT")]
	#[doc = "\n\n[Khronos reference: `vkQueueInsertDebugUtilsLabelEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueueInsertDebugUtilsLabelEXT.html)"]
	#[inline]
	pub unsafe fn queue_insert_debug_utils_label_ext(
		&self,
		queue: vk::Queue,
		p_label_info: *const vk::DebugUtilsLabelEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { queue_insert_debug_utils_label_ext(self, queue, p_label_info) }
	}
}

/// Call `vkCmdBeginDebugUtilsLabelEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBeginDebugUtilsLabelEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBeginDebugUtilsLabelEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdBeginDebugUtilsLabelEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginDebugUtilsLabelEXT.html)"]
pub unsafe fn cmd_begin_debug_utils_label_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_label_info: *const vk::DebugUtilsLabelEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_begin_debug_utils_label_ext
		.ok_or(CallError::MissingCommand("vkCmdBeginDebugUtilsLabelEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_label_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBeginDebugUtilsLabelEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBeginDebugUtilsLabelEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBeginDebugUtilsLabelEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdBeginDebugUtilsLabelEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginDebugUtilsLabelEXT.html)"]
	#[inline]
	pub unsafe fn cmd_begin_debug_utils_label_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_label_info: *const vk::DebugUtilsLabelEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_begin_debug_utils_label_ext(self, command_buffer, p_label_info) }
	}
}

/// Call `vkCmdEndDebugUtilsLabelEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdEndDebugUtilsLabelEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdEndDebugUtilsLabelEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdEndDebugUtilsLabelEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndDebugUtilsLabelEXT.html)"]
pub unsafe fn cmd_end_debug_utils_label_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_end_debug_utils_label_ext
		.ok_or(CallError::MissingCommand("vkCmdEndDebugUtilsLabelEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer) };
	Ok(())
}

impl Device {
	/// Call `vkCmdEndDebugUtilsLabelEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdEndDebugUtilsLabelEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdEndDebugUtilsLabelEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdEndDebugUtilsLabelEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndDebugUtilsLabelEXT.html)"]
	#[inline]
	pub unsafe fn cmd_end_debug_utils_label_ext(
		&self,
		command_buffer: vk::CommandBuffer,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_end_debug_utils_label_ext(self, command_buffer) }
	}
}

/// Call `vkCmdInsertDebugUtilsLabelEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdInsertDebugUtilsLabelEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdInsertDebugUtilsLabelEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdInsertDebugUtilsLabelEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdInsertDebugUtilsLabelEXT.html)"]
pub unsafe fn cmd_insert_debug_utils_label_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_label_info: *const vk::DebugUtilsLabelEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_insert_debug_utils_label_ext
		.ok_or(CallError::MissingCommand("vkCmdInsertDebugUtilsLabelEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_label_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdInsertDebugUtilsLabelEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdInsertDebugUtilsLabelEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdInsertDebugUtilsLabelEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdInsertDebugUtilsLabelEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdInsertDebugUtilsLabelEXT.html)"]
	#[inline]
	pub unsafe fn cmd_insert_debug_utils_label_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_label_info: *const vk::DebugUtilsLabelEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_insert_debug_utils_label_ext(self, command_buffer, p_label_info) }
	}
}

/// Call `vkCreateDebugUtilsMessengerEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateDebugUtilsMessengerEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateDebugUtilsMessengerEXT")]
#[doc = "\n\n[Khronos reference: `vkCreateDebugUtilsMessengerEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDebugUtilsMessengerEXT.html)"]
pub unsafe fn create_debug_utils_messenger_ext(
	instance: &Instance,
	p_create_info: *const vk::DebugUtilsMessengerCreateInfoEXT<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_messenger: *mut vk::DebugUtilsMessengerEXT,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.create_debug_utils_messenger_ext
		.ok_or(CallError::MissingCommand("vkCreateDebugUtilsMessengerEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), p_create_info, p_allocator, p_messenger) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkCreateDebugUtilsMessengerEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateDebugUtilsMessengerEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateDebugUtilsMessengerEXT")]
	#[doc = "\n\n[Khronos reference: `vkCreateDebugUtilsMessengerEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDebugUtilsMessengerEXT.html)"]
	#[inline]
	pub unsafe fn create_debug_utils_messenger_ext(
		&self,
		p_create_info: *const vk::DebugUtilsMessengerCreateInfoEXT<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_messenger: *mut vk::DebugUtilsMessengerEXT,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_debug_utils_messenger_ext(self, p_create_info, p_allocator, p_messenger) }
	}
}

/// Call `vkDestroyDebugUtilsMessengerEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyDebugUtilsMessengerEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyDebugUtilsMessengerEXT")]
#[doc = "\n\n[Khronos reference: `vkDestroyDebugUtilsMessengerEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyDebugUtilsMessengerEXT.html)"]
pub unsafe fn destroy_debug_utils_messenger_ext(
	instance: &Instance,
	messenger: vk::DebugUtilsMessengerEXT,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.destroy_debug_utils_messenger_ext
		.ok_or(CallError::MissingCommand("vkDestroyDebugUtilsMessengerEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(instance.handle(), messenger, p_allocator) };
	Ok(())
}

impl Instance {
	/// Call `vkDestroyDebugUtilsMessengerEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyDebugUtilsMessengerEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyDebugUtilsMessengerEXT")]
	#[doc = "\n\n[Khronos reference: `vkDestroyDebugUtilsMessengerEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyDebugUtilsMessengerEXT.html)"]
	#[inline]
	pub unsafe fn destroy_debug_utils_messenger_ext(
		&self,
		messenger: vk::DebugUtilsMessengerEXT,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_debug_utils_messenger_ext(self, messenger, p_allocator) }
	}
}

/// Call `vkSubmitDebugUtilsMessageEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkSubmitDebugUtilsMessageEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkSubmitDebugUtilsMessageEXT")]
#[doc = "\n\n[Khronos reference: `vkSubmitDebugUtilsMessageEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSubmitDebugUtilsMessageEXT.html)"]
pub unsafe fn submit_debug_utils_message_ext(
	instance: &Instance,
	message_severity: vk::DebugUtilsMessageSeverityFlagBitsEXT,
	message_types: vk::DebugUtilsMessageTypeFlagsEXT,
	p_callback_data: *const vk::DebugUtilsMessengerCallbackDataEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.submit_debug_utils_message_ext
		.ok_or(CallError::MissingCommand("vkSubmitDebugUtilsMessageEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			instance.handle(),
			message_severity,
			message_types,
			p_callback_data,
		)
	};
	Ok(())
}

impl Instance {
	/// Call `vkSubmitDebugUtilsMessageEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkSubmitDebugUtilsMessageEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkSubmitDebugUtilsMessageEXT")]
	#[doc = "\n\n[Khronos reference: `vkSubmitDebugUtilsMessageEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSubmitDebugUtilsMessageEXT.html)"]
	#[inline]
	pub unsafe fn submit_debug_utils_message_ext(
		&self,
		message_severity: vk::DebugUtilsMessageSeverityFlagBitsEXT,
		message_types: vk::DebugUtilsMessageTypeFlagsEXT,
		p_callback_data: *const vk::DebugUtilsMessengerCallbackDataEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			submit_debug_utils_message_ext(self, message_severity, message_types, p_callback_data)
		}
	}
}

/// Call `vkGetMemoryHostPointerPropertiesEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetMemoryHostPointerPropertiesEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetMemoryHostPointerPropertiesEXT")]
#[doc = "\n\n[Khronos reference: `vkGetMemoryHostPointerPropertiesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryHostPointerPropertiesEXT.html)"]
pub unsafe fn get_memory_host_pointer_properties_ext(
	device: &Device,
	handle_type: vk::ExternalMemoryHandleTypeFlagBits,
	p_host_pointer: *const std::ffi::c_void,
	p_memory_host_pointer_properties: *mut vk::MemoryHostPointerPropertiesEXT<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.get_memory_host_pointer_properties_ext
			.ok_or(CallError::MissingCommand(
				"vkGetMemoryHostPointerPropertiesEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			handle_type,
			p_host_pointer,
			p_memory_host_pointer_properties,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetMemoryHostPointerPropertiesEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetMemoryHostPointerPropertiesEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetMemoryHostPointerPropertiesEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetMemoryHostPointerPropertiesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryHostPointerPropertiesEXT.html)"]
	#[inline]
	pub unsafe fn get_memory_host_pointer_properties_ext(
		&self,
		handle_type: vk::ExternalMemoryHandleTypeFlagBits,
		p_host_pointer: *const std::ffi::c_void,
		p_memory_host_pointer_properties: *mut vk::MemoryHostPointerPropertiesEXT<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_memory_host_pointer_properties_ext(
				self,
				handle_type,
				p_host_pointer,
				p_memory_host_pointer_properties,
			)
		}
	}
}

/// Call `vkCmdWriteBufferMarkerAMD` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdWriteBufferMarkerAMD` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdWriteBufferMarkerAMD")]
#[doc = "\n\n[Khronos reference: `vkCmdWriteBufferMarkerAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWriteBufferMarkerAMD.html)"]
pub unsafe fn cmd_write_buffer_marker_amd(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	pipeline_stage: vk::PipelineStageFlagBits,
	dst_buffer: vk::Buffer,
	dst_offset: vk::DeviceSize,
	marker: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_write_buffer_marker_amd
		.ok_or(CallError::MissingCommand("vkCmdWriteBufferMarkerAMD"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			pipeline_stage,
			dst_buffer,
			dst_offset,
			marker,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdWriteBufferMarkerAMD` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdWriteBufferMarkerAMD` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdWriteBufferMarkerAMD")]
	#[doc = "\n\n[Khronos reference: `vkCmdWriteBufferMarkerAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWriteBufferMarkerAMD.html)"]
	#[inline]
	pub unsafe fn cmd_write_buffer_marker_amd(
		&self,
		command_buffer: vk::CommandBuffer,
		pipeline_stage: vk::PipelineStageFlagBits,
		dst_buffer: vk::Buffer,
		dst_offset: vk::DeviceSize,
		marker: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_write_buffer_marker_amd(
				self,
				command_buffer,
				pipeline_stage,
				dst_buffer,
				dst_offset,
				marker,
			)
		}
	}
}

/// Call `vkCreateRenderPass2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateRenderPass2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCreateRenderPass2")]
#[doc = "\n\n[Khronos reference: `vkCreateRenderPass2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateRenderPass2.html)"]
pub unsafe fn create_render_pass2(
	device: &Device,
	create_info: &vk::RenderPassCreateInfo2<'_>,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<vk::RenderPass, CallError> {
	let __vk_function = device
		.fp()
		.create_render_pass2
		.ok_or(CallError::MissingCommand("vkCreateRenderPass2"))?;
	let mut output = vk::RenderPass::NULL;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info,
			allocator.map_or(std::ptr::null(), |value| value),
			&mut output,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(output)
}

impl Device {
	/// Call `vkCreateRenderPass2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateRenderPass2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCreateRenderPass2")]
	#[doc = "\n\n[Khronos reference: `vkCreateRenderPass2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateRenderPass2.html)"]
	#[inline]
	pub unsafe fn create_render_pass2(
		&self,
		create_info: &vk::RenderPassCreateInfo2<'_>,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<vk::RenderPass, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_render_pass2(self, create_info, allocator) }
	}
}

/// Call `vkCreateRenderPass2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateRenderPass2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCreateRenderPass2KHR")]
#[doc = "\n\n[Khronos reference: `vkCreateRenderPass2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateRenderPass2KHR.html)"]
pub unsafe fn create_render_pass2_khr(
	device: &Device,
	create_info: &vk::RenderPassCreateInfo2<'_>,
	allocator: Option<&vk::AllocationCallbacks>,
) -> Result<vk::RenderPass, CallError> {
	let __vk_function = device
		.fp()
		.create_render_pass2_khr
		.ok_or(CallError::MissingCommand("vkCreateRenderPass2KHR"))?;
	let mut output = vk::RenderPass::NULL;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info,
			allocator.map_or(std::ptr::null(), |value| value),
			&mut output,
		)
	};
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(output)
}

impl Device {
	/// Call `vkCreateRenderPass2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateRenderPass2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCreateRenderPass2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCreateRenderPass2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateRenderPass2KHR.html)"]
	#[inline]
	pub unsafe fn create_render_pass2_khr(
		&self,
		create_info: &vk::RenderPassCreateInfo2<'_>,
		allocator: Option<&vk::AllocationCallbacks>,
	) -> Result<vk::RenderPass, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_render_pass2_khr(self, create_info, allocator) }
	}
}

/// Call `vkCmdBeginRenderPass2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBeginRenderPass2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdBeginRenderPass2")]
#[doc = "\n\n[Khronos reference: `vkCmdBeginRenderPass2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginRenderPass2.html)"]
pub unsafe fn cmd_begin_render_pass2(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	render_pass_begin: &vk::RenderPassBeginInfo<'_>,
	subpass_begin_info: &vk::SubpassBeginInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_begin_render_pass2
		.ok_or(CallError::MissingCommand("vkCmdBeginRenderPass2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, render_pass_begin, subpass_begin_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBeginRenderPass2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBeginRenderPass2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdBeginRenderPass2")]
	#[doc = "\n\n[Khronos reference: `vkCmdBeginRenderPass2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginRenderPass2.html)"]
	#[inline]
	pub unsafe fn cmd_begin_render_pass2(
		&self,
		command_buffer: vk::CommandBuffer,
		render_pass_begin: &vk::RenderPassBeginInfo<'_>,
		subpass_begin_info: &vk::SubpassBeginInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_begin_render_pass2(self, command_buffer, render_pass_begin, subpass_begin_info) }
	}
}

/// Call `vkCmdBeginRenderPass2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBeginRenderPass2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdBeginRenderPass2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdBeginRenderPass2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginRenderPass2KHR.html)"]
pub unsafe fn cmd_begin_render_pass2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	render_pass_begin: &vk::RenderPassBeginInfo<'_>,
	subpass_begin_info: &vk::SubpassBeginInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_begin_render_pass2_khr
		.ok_or(CallError::MissingCommand("vkCmdBeginRenderPass2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, render_pass_begin, subpass_begin_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBeginRenderPass2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBeginRenderPass2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdBeginRenderPass2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdBeginRenderPass2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginRenderPass2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_begin_render_pass2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		render_pass_begin: &vk::RenderPassBeginInfo<'_>,
		subpass_begin_info: &vk::SubpassBeginInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_begin_render_pass2_khr(self, command_buffer, render_pass_begin, subpass_begin_info)
		}
	}
}

/// Call `vkCmdNextSubpass2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdNextSubpass2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdNextSubpass2")]
#[doc = "\n\n[Khronos reference: `vkCmdNextSubpass2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdNextSubpass2.html)"]
pub unsafe fn cmd_next_subpass2(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	subpass_begin_info: &vk::SubpassBeginInfo<'_>,
	subpass_end_info: &vk::SubpassEndInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_next_subpass2
		.ok_or(CallError::MissingCommand("vkCmdNextSubpass2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, subpass_begin_info, subpass_end_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdNextSubpass2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdNextSubpass2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdNextSubpass2")]
	#[doc = "\n\n[Khronos reference: `vkCmdNextSubpass2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdNextSubpass2.html)"]
	#[inline]
	pub unsafe fn cmd_next_subpass2(
		&self,
		command_buffer: vk::CommandBuffer,
		subpass_begin_info: &vk::SubpassBeginInfo<'_>,
		subpass_end_info: &vk::SubpassEndInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_next_subpass2(self, command_buffer, subpass_begin_info, subpass_end_info) }
	}
}

/// Call `vkCmdNextSubpass2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdNextSubpass2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdNextSubpass2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdNextSubpass2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdNextSubpass2KHR.html)"]
pub unsafe fn cmd_next_subpass2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	subpass_begin_info: &vk::SubpassBeginInfo<'_>,
	subpass_end_info: &vk::SubpassEndInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_next_subpass2_khr
		.ok_or(CallError::MissingCommand("vkCmdNextSubpass2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, subpass_begin_info, subpass_end_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdNextSubpass2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdNextSubpass2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdNextSubpass2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdNextSubpass2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdNextSubpass2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_next_subpass2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		subpass_begin_info: &vk::SubpassBeginInfo<'_>,
		subpass_end_info: &vk::SubpassEndInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_next_subpass2_khr(self, command_buffer, subpass_begin_info, subpass_end_info) }
	}
}

/// Call `vkCmdEndRenderPass2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdEndRenderPass2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdEndRenderPass2")]
#[doc = "\n\n[Khronos reference: `vkCmdEndRenderPass2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndRenderPass2.html)"]
pub unsafe fn cmd_end_render_pass2(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	subpass_end_info: &vk::SubpassEndInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_end_render_pass2
		.ok_or(CallError::MissingCommand("vkCmdEndRenderPass2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, subpass_end_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdEndRenderPass2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdEndRenderPass2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdEndRenderPass2")]
	#[doc = "\n\n[Khronos reference: `vkCmdEndRenderPass2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndRenderPass2.html)"]
	#[inline]
	pub unsafe fn cmd_end_render_pass2(
		&self,
		command_buffer: vk::CommandBuffer,
		subpass_end_info: &vk::SubpassEndInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_end_render_pass2(self, command_buffer, subpass_end_info) }
	}
}

/// Call `vkCmdEndRenderPass2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdEndRenderPass2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdEndRenderPass2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdEndRenderPass2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndRenderPass2KHR.html)"]
pub unsafe fn cmd_end_render_pass2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	subpass_end_info: &vk::SubpassEndInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_end_render_pass2_khr
		.ok_or(CallError::MissingCommand("vkCmdEndRenderPass2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, subpass_end_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdEndRenderPass2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdEndRenderPass2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdEndRenderPass2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdEndRenderPass2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndRenderPass2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_end_render_pass2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		subpass_end_info: &vk::SubpassEndInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_end_render_pass2_khr(self, command_buffer, subpass_end_info) }
	}
}

/// Call `vkGetSemaphoreCounterValue` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetSemaphoreCounterValue` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetSemaphoreCounterValue")]
#[doc = "\n\n[Khronos reference: `vkGetSemaphoreCounterValue`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSemaphoreCounterValue.html)"]
pub unsafe fn get_semaphore_counter_value(
	device: &Device,
	semaphore: vk::Semaphore,
	value: &mut u64,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_semaphore_counter_value
		.ok_or(CallError::MissingCommand("vkGetSemaphoreCounterValue"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), semaphore, value) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkGetSemaphoreCounterValue` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetSemaphoreCounterValue` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetSemaphoreCounterValue")]
	#[doc = "\n\n[Khronos reference: `vkGetSemaphoreCounterValue`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSemaphoreCounterValue.html)"]
	#[inline]
	pub unsafe fn get_semaphore_counter_value(
		&self,
		semaphore: vk::Semaphore,
		value: &mut u64,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_semaphore_counter_value(self, semaphore, value) }
	}
}

/// Call `vkGetSemaphoreCounterValueKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetSemaphoreCounterValueKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkGetSemaphoreCounterValueKHR")]
#[doc = "\n\n[Khronos reference: `vkGetSemaphoreCounterValueKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSemaphoreCounterValueKHR.html)"]
pub unsafe fn get_semaphore_counter_value_khr(
	device: &Device,
	semaphore: vk::Semaphore,
	value: &mut u64,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_semaphore_counter_value_khr
		.ok_or(CallError::MissingCommand("vkGetSemaphoreCounterValueKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), semaphore, value) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkGetSemaphoreCounterValueKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetSemaphoreCounterValueKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkGetSemaphoreCounterValueKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetSemaphoreCounterValueKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSemaphoreCounterValueKHR.html)"]
	#[inline]
	pub unsafe fn get_semaphore_counter_value_khr(
		&self,
		semaphore: vk::Semaphore,
		value: &mut u64,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_semaphore_counter_value_khr(self, semaphore, value) }
	}
}

/// Call `vkWaitSemaphores` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkWaitSemaphores` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkWaitSemaphores")]
#[doc = "\n\n[Khronos reference: `vkWaitSemaphores`](https://docs.vulkan.org/refpages/latest/refpages/source/vkWaitSemaphores.html)"]
pub unsafe fn wait_semaphores(
	device: &Device,
	wait_info: &vk::SemaphoreWaitInfo<'_>,
	timeout: u64,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.wait_semaphores
		.ok_or(CallError::MissingCommand("vkWaitSemaphores"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), wait_info, timeout) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkWaitSemaphores` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkWaitSemaphores` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkWaitSemaphores")]
	#[doc = "\n\n[Khronos reference: `vkWaitSemaphores`](https://docs.vulkan.org/refpages/latest/refpages/source/vkWaitSemaphores.html)"]
	#[inline]
	pub unsafe fn wait_semaphores(
		&self,
		wait_info: &vk::SemaphoreWaitInfo<'_>,
		timeout: u64,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { wait_semaphores(self, wait_info, timeout) }
	}
}

/// Call `vkWaitSemaphoresKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkWaitSemaphoresKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkWaitSemaphoresKHR")]
#[doc = "\n\n[Khronos reference: `vkWaitSemaphoresKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkWaitSemaphoresKHR.html)"]
pub unsafe fn wait_semaphores_khr(
	device: &Device,
	wait_info: &vk::SemaphoreWaitInfo<'_>,
	timeout: u64,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.wait_semaphores_khr
		.ok_or(CallError::MissingCommand("vkWaitSemaphoresKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), wait_info, timeout) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkWaitSemaphoresKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkWaitSemaphoresKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkWaitSemaphoresKHR")]
	#[doc = "\n\n[Khronos reference: `vkWaitSemaphoresKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkWaitSemaphoresKHR.html)"]
	#[inline]
	pub unsafe fn wait_semaphores_khr(
		&self,
		wait_info: &vk::SemaphoreWaitInfo<'_>,
		timeout: u64,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { wait_semaphores_khr(self, wait_info, timeout) }
	}
}

/// Call `vkSignalSemaphore` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkSignalSemaphore` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkSignalSemaphore")]
#[doc = "\n\n[Khronos reference: `vkSignalSemaphore`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSignalSemaphore.html)"]
pub unsafe fn signal_semaphore(
	device: &Device,
	signal_info: &vk::SemaphoreSignalInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.signal_semaphore
		.ok_or(CallError::MissingCommand("vkSignalSemaphore"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), signal_info) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkSignalSemaphore` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkSignalSemaphore` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkSignalSemaphore")]
	#[doc = "\n\n[Khronos reference: `vkSignalSemaphore`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSignalSemaphore.html)"]
	#[inline]
	pub unsafe fn signal_semaphore(
		&self,
		signal_info: &vk::SemaphoreSignalInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { signal_semaphore(self, signal_info) }
	}
}

/// Call `vkSignalSemaphoreKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkSignalSemaphoreKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkSignalSemaphoreKHR")]
#[doc = "\n\n[Khronos reference: `vkSignalSemaphoreKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSignalSemaphoreKHR.html)"]
pub unsafe fn signal_semaphore_khr(
	device: &Device,
	signal_info: &vk::SemaphoreSignalInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.signal_semaphore_khr
		.ok_or(CallError::MissingCommand("vkSignalSemaphoreKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), signal_info) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkSignalSemaphoreKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkSignalSemaphoreKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkSignalSemaphoreKHR")]
	#[doc = "\n\n[Khronos reference: `vkSignalSemaphoreKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSignalSemaphoreKHR.html)"]
	#[inline]
	pub unsafe fn signal_semaphore_khr(
		&self,
		signal_info: &vk::SemaphoreSignalInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { signal_semaphore_khr(self, signal_info) }
	}
}

#[cfg(feature = "platform-android")]
/// Call `vkGetAndroidHardwareBufferPropertiesANDROID` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetAndroidHardwareBufferPropertiesANDROID` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetAndroidHardwareBufferPropertiesANDROID")]
#[doc = "\n\n[Khronos reference: `vkGetAndroidHardwareBufferPropertiesANDROID`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetAndroidHardwareBufferPropertiesANDROID.html)"]
pub unsafe fn get_android_hardware_buffer_properties_android(
	device: &Device,
	buffer: *const vk::AHardwareBuffer,
	p_properties: *mut vk::AndroidHardwareBufferPropertiesANDROID<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_android_hardware_buffer_properties_android
		.ok_or(CallError::MissingCommand(
			"vkGetAndroidHardwareBufferPropertiesANDROID",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), buffer, p_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-android")]
impl Device {
	/// Call `vkGetAndroidHardwareBufferPropertiesANDROID` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetAndroidHardwareBufferPropertiesANDROID` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetAndroidHardwareBufferPropertiesANDROID")]
	#[doc = "\n\n[Khronos reference: `vkGetAndroidHardwareBufferPropertiesANDROID`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetAndroidHardwareBufferPropertiesANDROID.html)"]
	#[inline]
	pub unsafe fn get_android_hardware_buffer_properties_android(
		&self,
		buffer: *const vk::AHardwareBuffer,
		p_properties: *mut vk::AndroidHardwareBufferPropertiesANDROID<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_android_hardware_buffer_properties_android(self, buffer, p_properties) }
	}
}

#[cfg(feature = "platform-android")]
/// Call `vkGetMemoryAndroidHardwareBufferANDROID` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetMemoryAndroidHardwareBufferANDROID` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetMemoryAndroidHardwareBufferANDROID")]
#[doc = "\n\n[Khronos reference: `vkGetMemoryAndroidHardwareBufferANDROID`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryAndroidHardwareBufferANDROID.html)"]
pub unsafe fn get_memory_android_hardware_buffer_android(
	device: &Device,
	p_info: *const vk::MemoryGetAndroidHardwareBufferInfoANDROID<'_>,
	p_buffer: *mut *mut vk::AHardwareBuffer,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_memory_android_hardware_buffer_android
		.ok_or(CallError::MissingCommand(
			"vkGetMemoryAndroidHardwareBufferANDROID",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_info, p_buffer) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-android")]
impl Device {
	/// Call `vkGetMemoryAndroidHardwareBufferANDROID` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetMemoryAndroidHardwareBufferANDROID` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetMemoryAndroidHardwareBufferANDROID")]
	#[doc = "\n\n[Khronos reference: `vkGetMemoryAndroidHardwareBufferANDROID`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryAndroidHardwareBufferANDROID.html)"]
	#[inline]
	pub unsafe fn get_memory_android_hardware_buffer_android(
		&self,
		p_info: *const vk::MemoryGetAndroidHardwareBufferInfoANDROID<'_>,
		p_buffer: *mut *mut vk::AHardwareBuffer,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_memory_android_hardware_buffer_android(self, p_info, p_buffer) }
	}
}

/// Call `vkCmdDrawIndirectCount` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawIndirectCount` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdDrawIndirectCount")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawIndirectCount`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndirectCount.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_draw_indirect_count(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	buffer: vk::Buffer,
	offset: vk::DeviceSize,
	count_buffer: vk::Buffer,
	count_buffer_offset: vk::DeviceSize,
	max_draw_count: u32,
	stride: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_indirect_count
		.ok_or(CallError::MissingCommand("vkCmdDrawIndirectCount"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			buffer,
			offset,
			count_buffer,
			count_buffer_offset,
			max_draw_count,
			stride,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawIndirectCount` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawIndirectCount` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdDrawIndirectCount")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawIndirectCount`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndirectCount.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_draw_indirect_count(
		&self,
		command_buffer: vk::CommandBuffer,
		buffer: vk::Buffer,
		offset: vk::DeviceSize,
		count_buffer: vk::Buffer,
		count_buffer_offset: vk::DeviceSize,
		max_draw_count: u32,
		stride: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_draw_indirect_count(
				self,
				command_buffer,
				buffer,
				offset,
				count_buffer,
				count_buffer_offset,
				max_draw_count,
				stride,
			)
		}
	}
}

/// Call `vkCmdDrawIndirectCountKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawIndirectCountKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdDrawIndirectCountKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawIndirectCountKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndirectCountKHR.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_draw_indirect_count_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	buffer: vk::Buffer,
	offset: vk::DeviceSize,
	count_buffer: vk::Buffer,
	count_buffer_offset: vk::DeviceSize,
	max_draw_count: u32,
	stride: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_indirect_count_khr
		.ok_or(CallError::MissingCommand("vkCmdDrawIndirectCountKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			buffer,
			offset,
			count_buffer,
			count_buffer_offset,
			max_draw_count,
			stride,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawIndirectCountKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawIndirectCountKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdDrawIndirectCountKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawIndirectCountKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndirectCountKHR.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_draw_indirect_count_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		buffer: vk::Buffer,
		offset: vk::DeviceSize,
		count_buffer: vk::Buffer,
		count_buffer_offset: vk::DeviceSize,
		max_draw_count: u32,
		stride: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_draw_indirect_count_khr(
				self,
				command_buffer,
				buffer,
				offset,
				count_buffer,
				count_buffer_offset,
				max_draw_count,
				stride,
			)
		}
	}
}

/// Call `vkCmdDrawIndirectCountAMD` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawIndirectCountAMD` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdDrawIndirectCountAMD")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawIndirectCountAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndirectCountAMD.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_draw_indirect_count_amd(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	buffer: vk::Buffer,
	offset: vk::DeviceSize,
	count_buffer: vk::Buffer,
	count_buffer_offset: vk::DeviceSize,
	max_draw_count: u32,
	stride: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_indirect_count_amd
		.ok_or(CallError::MissingCommand("vkCmdDrawIndirectCountAMD"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			buffer,
			offset,
			count_buffer,
			count_buffer_offset,
			max_draw_count,
			stride,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawIndirectCountAMD` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawIndirectCountAMD` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdDrawIndirectCountAMD")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawIndirectCountAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndirectCountAMD.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_draw_indirect_count_amd(
		&self,
		command_buffer: vk::CommandBuffer,
		buffer: vk::Buffer,
		offset: vk::DeviceSize,
		count_buffer: vk::Buffer,
		count_buffer_offset: vk::DeviceSize,
		max_draw_count: u32,
		stride: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_draw_indirect_count_amd(
				self,
				command_buffer,
				buffer,
				offset,
				count_buffer,
				count_buffer_offset,
				max_draw_count,
				stride,
			)
		}
	}
}

/// Call `vkCmdDrawIndexedIndirectCount` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawIndexedIndirectCount` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdDrawIndexedIndirectCount")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawIndexedIndirectCount`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndexedIndirectCount.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_draw_indexed_indirect_count(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	buffer: vk::Buffer,
	offset: vk::DeviceSize,
	count_buffer: vk::Buffer,
	count_buffer_offset: vk::DeviceSize,
	max_draw_count: u32,
	stride: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_indexed_indirect_count
		.ok_or(CallError::MissingCommand("vkCmdDrawIndexedIndirectCount"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			buffer,
			offset,
			count_buffer,
			count_buffer_offset,
			max_draw_count,
			stride,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawIndexedIndirectCount` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawIndexedIndirectCount` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdDrawIndexedIndirectCount")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawIndexedIndirectCount`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndexedIndirectCount.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_draw_indexed_indirect_count(
		&self,
		command_buffer: vk::CommandBuffer,
		buffer: vk::Buffer,
		offset: vk::DeviceSize,
		count_buffer: vk::Buffer,
		count_buffer_offset: vk::DeviceSize,
		max_draw_count: u32,
		stride: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_draw_indexed_indirect_count(
				self,
				command_buffer,
				buffer,
				offset,
				count_buffer,
				count_buffer_offset,
				max_draw_count,
				stride,
			)
		}
	}
}

/// Call `vkCmdDrawIndexedIndirectCountKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawIndexedIndirectCountKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdDrawIndexedIndirectCountKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawIndexedIndirectCountKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndexedIndirectCountKHR.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_draw_indexed_indirect_count_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	buffer: vk::Buffer,
	offset: vk::DeviceSize,
	count_buffer: vk::Buffer,
	count_buffer_offset: vk::DeviceSize,
	max_draw_count: u32,
	stride: u32,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_draw_indexed_indirect_count_khr
			.ok_or(CallError::MissingCommand(
				"vkCmdDrawIndexedIndirectCountKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			buffer,
			offset,
			count_buffer,
			count_buffer_offset,
			max_draw_count,
			stride,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawIndexedIndirectCountKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawIndexedIndirectCountKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdDrawIndexedIndirectCountKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawIndexedIndirectCountKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndexedIndirectCountKHR.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_draw_indexed_indirect_count_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		buffer: vk::Buffer,
		offset: vk::DeviceSize,
		count_buffer: vk::Buffer,
		count_buffer_offset: vk::DeviceSize,
		max_draw_count: u32,
		stride: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_draw_indexed_indirect_count_khr(
				self,
				command_buffer,
				buffer,
				offset,
				count_buffer,
				count_buffer_offset,
				max_draw_count,
				stride,
			)
		}
	}
}

/// Call `vkCmdDrawIndexedIndirectCountAMD` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawIndexedIndirectCountAMD` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdDrawIndexedIndirectCountAMD")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawIndexedIndirectCountAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndexedIndirectCountAMD.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_draw_indexed_indirect_count_amd(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	buffer: vk::Buffer,
	offset: vk::DeviceSize,
	count_buffer: vk::Buffer,
	count_buffer_offset: vk::DeviceSize,
	max_draw_count: u32,
	stride: u32,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_draw_indexed_indirect_count_amd
			.ok_or(CallError::MissingCommand(
				"vkCmdDrawIndexedIndirectCountAMD",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			buffer,
			offset,
			count_buffer,
			count_buffer_offset,
			max_draw_count,
			stride,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawIndexedIndirectCountAMD` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawIndexedIndirectCountAMD` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdDrawIndexedIndirectCountAMD")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawIndexedIndirectCountAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndexedIndirectCountAMD.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_draw_indexed_indirect_count_amd(
		&self,
		command_buffer: vk::CommandBuffer,
		buffer: vk::Buffer,
		offset: vk::DeviceSize,
		count_buffer: vk::Buffer,
		count_buffer_offset: vk::DeviceSize,
		max_draw_count: u32,
		stride: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_draw_indexed_indirect_count_amd(
				self,
				command_buffer,
				buffer,
				offset,
				count_buffer,
				count_buffer_offset,
				max_draw_count,
				stride,
			)
		}
	}
}

/// Call `vkCmdSetCheckpointNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetCheckpointNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetCheckpointNV")]
#[doc = "\n\n[Khronos reference: `vkCmdSetCheckpointNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetCheckpointNV.html)"]
pub unsafe fn cmd_set_checkpoint_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_checkpoint_marker: *const std::ffi::c_void,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_checkpoint_nv
		.ok_or(CallError::MissingCommand("vkCmdSetCheckpointNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_checkpoint_marker) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetCheckpointNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetCheckpointNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetCheckpointNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetCheckpointNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetCheckpointNV.html)"]
	#[inline]
	pub unsafe fn cmd_set_checkpoint_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		p_checkpoint_marker: *const std::ffi::c_void,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_checkpoint_nv(self, command_buffer, p_checkpoint_marker) }
	}
}

/// Call `vkGetQueueCheckpointDataNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetQueueCheckpointDataNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetQueueCheckpointDataNV")]
#[doc = "\n\n[Khronos reference: `vkGetQueueCheckpointDataNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetQueueCheckpointDataNV.html)"]
pub unsafe fn get_queue_checkpoint_data_nv(
	device: &Device,
	queue: vk::Queue,
	p_checkpoint_data_count: *mut u32,
	p_checkpoint_data: *mut vk::CheckpointDataNV<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_queue_checkpoint_data_nv
		.ok_or(CallError::MissingCommand("vkGetQueueCheckpointDataNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(queue, p_checkpoint_data_count, p_checkpoint_data) };
	Ok(())
}

impl Device {
	/// Call `vkGetQueueCheckpointDataNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetQueueCheckpointDataNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetQueueCheckpointDataNV")]
	#[doc = "\n\n[Khronos reference: `vkGetQueueCheckpointDataNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetQueueCheckpointDataNV.html)"]
	#[inline]
	pub unsafe fn get_queue_checkpoint_data_nv(
		&self,
		queue: vk::Queue,
		p_checkpoint_data_count: *mut u32,
		p_checkpoint_data: *mut vk::CheckpointDataNV<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_queue_checkpoint_data_nv(self, queue, p_checkpoint_data_count, p_checkpoint_data) }
	}
}

/// Call `vkCmdBindTransformFeedbackBuffersEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindTransformFeedbackBuffersEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBindTransformFeedbackBuffersEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdBindTransformFeedbackBuffersEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindTransformFeedbackBuffersEXT.html)"]
pub unsafe fn cmd_bind_transform_feedback_buffers_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_binding: u32,
	binding_count: u32,
	p_buffers: *const vk::Buffer,
	p_offsets: *const vk::DeviceSize,
	p_sizes: *const vk::DeviceSize,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_bind_transform_feedback_buffers_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdBindTransformFeedbackBuffersEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_binding,
			binding_count,
			p_buffers,
			p_offsets,
			p_sizes,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdBindTransformFeedbackBuffersEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindTransformFeedbackBuffersEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBindTransformFeedbackBuffersEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindTransformFeedbackBuffersEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindTransformFeedbackBuffersEXT.html)"]
	#[inline]
	pub unsafe fn cmd_bind_transform_feedback_buffers_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		first_binding: u32,
		binding_count: u32,
		p_buffers: *const vk::Buffer,
		p_offsets: *const vk::DeviceSize,
		p_sizes: *const vk::DeviceSize,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_bind_transform_feedback_buffers_ext(
				self,
				command_buffer,
				first_binding,
				binding_count,
				p_buffers,
				p_offsets,
				p_sizes,
			)
		}
	}
}

/// Call `vkCmdBeginTransformFeedbackEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBeginTransformFeedbackEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBeginTransformFeedbackEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdBeginTransformFeedbackEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginTransformFeedbackEXT.html)"]
pub unsafe fn cmd_begin_transform_feedback_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_counter_buffer: u32,
	counter_buffer_count: u32,
	p_counter_buffers: *const vk::Buffer,
	p_counter_buffer_offsets: *const vk::DeviceSize,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_begin_transform_feedback_ext
		.ok_or(CallError::MissingCommand("vkCmdBeginTransformFeedbackEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_counter_buffer,
			counter_buffer_count,
			p_counter_buffers,
			p_counter_buffer_offsets,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdBeginTransformFeedbackEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBeginTransformFeedbackEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBeginTransformFeedbackEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdBeginTransformFeedbackEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginTransformFeedbackEXT.html)"]
	#[inline]
	pub unsafe fn cmd_begin_transform_feedback_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		first_counter_buffer: u32,
		counter_buffer_count: u32,
		p_counter_buffers: *const vk::Buffer,
		p_counter_buffer_offsets: *const vk::DeviceSize,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_begin_transform_feedback_ext(
				self,
				command_buffer,
				first_counter_buffer,
				counter_buffer_count,
				p_counter_buffers,
				p_counter_buffer_offsets,
			)
		}
	}
}

/// Call `vkCmdEndTransformFeedbackEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdEndTransformFeedbackEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdEndTransformFeedbackEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdEndTransformFeedbackEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndTransformFeedbackEXT.html)"]
pub unsafe fn cmd_end_transform_feedback_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_counter_buffer: u32,
	counter_buffer_count: u32,
	p_counter_buffers: *const vk::Buffer,
	p_counter_buffer_offsets: *const vk::DeviceSize,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_end_transform_feedback_ext
		.ok_or(CallError::MissingCommand("vkCmdEndTransformFeedbackEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_counter_buffer,
			counter_buffer_count,
			p_counter_buffers,
			p_counter_buffer_offsets,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdEndTransformFeedbackEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdEndTransformFeedbackEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdEndTransformFeedbackEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdEndTransformFeedbackEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndTransformFeedbackEXT.html)"]
	#[inline]
	pub unsafe fn cmd_end_transform_feedback_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		first_counter_buffer: u32,
		counter_buffer_count: u32,
		p_counter_buffers: *const vk::Buffer,
		p_counter_buffer_offsets: *const vk::DeviceSize,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_end_transform_feedback_ext(
				self,
				command_buffer,
				first_counter_buffer,
				counter_buffer_count,
				p_counter_buffers,
				p_counter_buffer_offsets,
			)
		}
	}
}

/// Call `vkCmdBeginQueryIndexedEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBeginQueryIndexedEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBeginQueryIndexedEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdBeginQueryIndexedEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginQueryIndexedEXT.html)"]
pub unsafe fn cmd_begin_query_indexed_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	query_pool: vk::QueryPool,
	query: u32,
	flags: vk::QueryControlFlags,
	index: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_begin_query_indexed_ext
		.ok_or(CallError::MissingCommand("vkCmdBeginQueryIndexedEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, query_pool, query, flags, index) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBeginQueryIndexedEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBeginQueryIndexedEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBeginQueryIndexedEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdBeginQueryIndexedEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginQueryIndexedEXT.html)"]
	#[inline]
	pub unsafe fn cmd_begin_query_indexed_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		query_pool: vk::QueryPool,
		query: u32,
		flags: vk::QueryControlFlags,
		index: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_begin_query_indexed_ext(self, command_buffer, query_pool, query, flags, index) }
	}
}

/// Call `vkCmdEndQueryIndexedEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdEndQueryIndexedEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdEndQueryIndexedEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdEndQueryIndexedEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndQueryIndexedEXT.html)"]
pub unsafe fn cmd_end_query_indexed_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	query_pool: vk::QueryPool,
	query: u32,
	index: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_end_query_indexed_ext
		.ok_or(CallError::MissingCommand("vkCmdEndQueryIndexedEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, query_pool, query, index) };
	Ok(())
}

impl Device {
	/// Call `vkCmdEndQueryIndexedEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdEndQueryIndexedEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdEndQueryIndexedEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdEndQueryIndexedEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndQueryIndexedEXT.html)"]
	#[inline]
	pub unsafe fn cmd_end_query_indexed_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		query_pool: vk::QueryPool,
		query: u32,
		index: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_end_query_indexed_ext(self, command_buffer, query_pool, query, index) }
	}
}

/// Call `vkCmdDrawIndirectByteCountEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawIndirectByteCountEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDrawIndirectByteCountEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawIndirectByteCountEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndirectByteCountEXT.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_draw_indirect_byte_count_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	instance_count: u32,
	first_instance: u32,
	counter_buffer: vk::Buffer,
	counter_buffer_offset: vk::DeviceSize,
	counter_offset: u32,
	vertex_stride: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_indirect_byte_count_ext
		.ok_or(CallError::MissingCommand("vkCmdDrawIndirectByteCountEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			instance_count,
			first_instance,
			counter_buffer,
			counter_buffer_offset,
			counter_offset,
			vertex_stride,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawIndirectByteCountEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawIndirectByteCountEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDrawIndirectByteCountEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawIndirectByteCountEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndirectByteCountEXT.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_draw_indirect_byte_count_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		instance_count: u32,
		first_instance: u32,
		counter_buffer: vk::Buffer,
		counter_buffer_offset: vk::DeviceSize,
		counter_offset: u32,
		vertex_stride: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_draw_indirect_byte_count_ext(
				self,
				command_buffer,
				instance_count,
				first_instance,
				counter_buffer,
				counter_buffer_offset,
				counter_offset,
				vertex_stride,
			)
		}
	}
}

/// Call `vkCmdSetExclusiveScissorNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetExclusiveScissorNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetExclusiveScissorNV")]
#[doc = "\n\n[Khronos reference: `vkCmdSetExclusiveScissorNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetExclusiveScissorNV.html)"]
pub unsafe fn cmd_set_exclusive_scissor_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_exclusive_scissor: u32,
	exclusive_scissor_count: u32,
	p_exclusive_scissors: *const vk::Rect2D,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_exclusive_scissor_nv
		.ok_or(CallError::MissingCommand("vkCmdSetExclusiveScissorNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_exclusive_scissor,
			exclusive_scissor_count,
			p_exclusive_scissors,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdSetExclusiveScissorNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetExclusiveScissorNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetExclusiveScissorNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetExclusiveScissorNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetExclusiveScissorNV.html)"]
	#[inline]
	pub unsafe fn cmd_set_exclusive_scissor_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		first_exclusive_scissor: u32,
		exclusive_scissor_count: u32,
		p_exclusive_scissors: *const vk::Rect2D,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_exclusive_scissor_nv(
				self,
				command_buffer,
				first_exclusive_scissor,
				exclusive_scissor_count,
				p_exclusive_scissors,
			)
		}
	}
}

/// Call `vkCmdSetExclusiveScissorEnableNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetExclusiveScissorEnableNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetExclusiveScissorEnableNV")]
#[doc = "\n\n[Khronos reference: `vkCmdSetExclusiveScissorEnableNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetExclusiveScissorEnableNV.html)"]
pub unsafe fn cmd_set_exclusive_scissor_enable_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_exclusive_scissor: u32,
	exclusive_scissor_count: u32,
	p_exclusive_scissor_enables: *const vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_exclusive_scissor_enable_nv
			.ok_or(CallError::MissingCommand(
				"vkCmdSetExclusiveScissorEnableNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_exclusive_scissor,
			exclusive_scissor_count,
			p_exclusive_scissor_enables,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdSetExclusiveScissorEnableNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetExclusiveScissorEnableNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetExclusiveScissorEnableNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetExclusiveScissorEnableNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetExclusiveScissorEnableNV.html)"]
	#[inline]
	pub unsafe fn cmd_set_exclusive_scissor_enable_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		first_exclusive_scissor: u32,
		exclusive_scissor_count: u32,
		p_exclusive_scissor_enables: *const vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_exclusive_scissor_enable_nv(
				self,
				command_buffer,
				first_exclusive_scissor,
				exclusive_scissor_count,
				p_exclusive_scissor_enables,
			)
		}
	}
}

/// Call `vkCmdBindShadingRateImageNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindShadingRateImageNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBindShadingRateImageNV")]
#[doc = "\n\n[Khronos reference: `vkCmdBindShadingRateImageNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindShadingRateImageNV.html)"]
pub unsafe fn cmd_bind_shading_rate_image_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	image_view: vk::ImageView,
	image_layout: vk::ImageLayout,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_shading_rate_image_nv
		.ok_or(CallError::MissingCommand("vkCmdBindShadingRateImageNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, image_view, image_layout) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBindShadingRateImageNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindShadingRateImageNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBindShadingRateImageNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindShadingRateImageNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindShadingRateImageNV.html)"]
	#[inline]
	pub unsafe fn cmd_bind_shading_rate_image_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		image_view: vk::ImageView,
		image_layout: vk::ImageLayout,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_bind_shading_rate_image_nv(self, command_buffer, image_view, image_layout) }
	}
}

/// Call `vkCmdSetViewportShadingRatePaletteNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetViewportShadingRatePaletteNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetViewportShadingRatePaletteNV")]
#[doc = "\n\n[Khronos reference: `vkCmdSetViewportShadingRatePaletteNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetViewportShadingRatePaletteNV.html)"]
pub unsafe fn cmd_set_viewport_shading_rate_palette_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_viewport: u32,
	viewport_count: u32,
	p_shading_rate_palettes: *const vk::ShadingRatePaletteNV<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_viewport_shading_rate_palette_nv
			.ok_or(CallError::MissingCommand(
				"vkCmdSetViewportShadingRatePaletteNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_viewport,
			viewport_count,
			p_shading_rate_palettes,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdSetViewportShadingRatePaletteNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetViewportShadingRatePaletteNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetViewportShadingRatePaletteNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetViewportShadingRatePaletteNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetViewportShadingRatePaletteNV.html)"]
	#[inline]
	pub unsafe fn cmd_set_viewport_shading_rate_palette_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		first_viewport: u32,
		viewport_count: u32,
		p_shading_rate_palettes: *const vk::ShadingRatePaletteNV<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_viewport_shading_rate_palette_nv(
				self,
				command_buffer,
				first_viewport,
				viewport_count,
				p_shading_rate_palettes,
			)
		}
	}
}

/// Call `vkCmdSetCoarseSampleOrderNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetCoarseSampleOrderNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetCoarseSampleOrderNV")]
#[doc = "\n\n[Khronos reference: `vkCmdSetCoarseSampleOrderNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetCoarseSampleOrderNV.html)"]
pub unsafe fn cmd_set_coarse_sample_order_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	sample_order_type: vk::CoarseSampleOrderTypeNV,
	custom_sample_order_count: u32,
	p_custom_sample_orders: *const vk::CoarseSampleOrderCustomNV<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_coarse_sample_order_nv
		.ok_or(CallError::MissingCommand("vkCmdSetCoarseSampleOrderNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			sample_order_type,
			custom_sample_order_count,
			p_custom_sample_orders,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdSetCoarseSampleOrderNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetCoarseSampleOrderNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetCoarseSampleOrderNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetCoarseSampleOrderNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetCoarseSampleOrderNV.html)"]
	#[inline]
	pub unsafe fn cmd_set_coarse_sample_order_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		sample_order_type: vk::CoarseSampleOrderTypeNV,
		custom_sample_order_count: u32,
		p_custom_sample_orders: *const vk::CoarseSampleOrderCustomNV<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_coarse_sample_order_nv(
				self,
				command_buffer,
				sample_order_type,
				custom_sample_order_count,
				p_custom_sample_orders,
			)
		}
	}
}

/// Call `vkCmdDrawMeshTasksNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawMeshTasksNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDrawMeshTasksNV")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawMeshTasksNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawMeshTasksNV.html)"]
pub unsafe fn cmd_draw_mesh_tasks_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	task_count: u32,
	first_task: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_mesh_tasks_nv
		.ok_or(CallError::MissingCommand("vkCmdDrawMeshTasksNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, task_count, first_task) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawMeshTasksNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawMeshTasksNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDrawMeshTasksNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawMeshTasksNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawMeshTasksNV.html)"]
	#[inline]
	pub unsafe fn cmd_draw_mesh_tasks_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		task_count: u32,
		first_task: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_draw_mesh_tasks_nv(self, command_buffer, task_count, first_task) }
	}
}

/// Call `vkCmdDrawMeshTasksIndirectNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawMeshTasksIndirectNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDrawMeshTasksIndirectNV")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawMeshTasksIndirectNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawMeshTasksIndirectNV.html)"]
pub unsafe fn cmd_draw_mesh_tasks_indirect_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	buffer: vk::Buffer,
	offset: vk::DeviceSize,
	draw_count: u32,
	stride: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_mesh_tasks_indirect_nv
		.ok_or(CallError::MissingCommand("vkCmdDrawMeshTasksIndirectNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, buffer, offset, draw_count, stride) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawMeshTasksIndirectNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawMeshTasksIndirectNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDrawMeshTasksIndirectNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawMeshTasksIndirectNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawMeshTasksIndirectNV.html)"]
	#[inline]
	pub unsafe fn cmd_draw_mesh_tasks_indirect_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		buffer: vk::Buffer,
		offset: vk::DeviceSize,
		draw_count: u32,
		stride: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_draw_mesh_tasks_indirect_nv(self, command_buffer, buffer, offset, draw_count, stride)
		}
	}
}

/// Call `vkCmdDrawMeshTasksIndirectCountNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawMeshTasksIndirectCountNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDrawMeshTasksIndirectCountNV")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawMeshTasksIndirectCountNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawMeshTasksIndirectCountNV.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_draw_mesh_tasks_indirect_count_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	buffer: vk::Buffer,
	offset: vk::DeviceSize,
	count_buffer: vk::Buffer,
	count_buffer_offset: vk::DeviceSize,
	max_draw_count: u32,
	stride: u32,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_draw_mesh_tasks_indirect_count_nv
			.ok_or(CallError::MissingCommand(
				"vkCmdDrawMeshTasksIndirectCountNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			buffer,
			offset,
			count_buffer,
			count_buffer_offset,
			max_draw_count,
			stride,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawMeshTasksIndirectCountNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawMeshTasksIndirectCountNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDrawMeshTasksIndirectCountNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawMeshTasksIndirectCountNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawMeshTasksIndirectCountNV.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_draw_mesh_tasks_indirect_count_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		buffer: vk::Buffer,
		offset: vk::DeviceSize,
		count_buffer: vk::Buffer,
		count_buffer_offset: vk::DeviceSize,
		max_draw_count: u32,
		stride: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_draw_mesh_tasks_indirect_count_nv(
				self,
				command_buffer,
				buffer,
				offset,
				count_buffer,
				count_buffer_offset,
				max_draw_count,
				stride,
			)
		}
	}
}

/// Call `vkCmdDrawMeshTasksEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawMeshTasksEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDrawMeshTasksEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawMeshTasksEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawMeshTasksEXT.html)"]
pub unsafe fn cmd_draw_mesh_tasks_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	group_count_x: u32,
	group_count_y: u32,
	group_count_z: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_mesh_tasks_ext
		.ok_or(CallError::MissingCommand("vkCmdDrawMeshTasksEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, group_count_x, group_count_y, group_count_z) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawMeshTasksEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawMeshTasksEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDrawMeshTasksEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawMeshTasksEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawMeshTasksEXT.html)"]
	#[inline]
	pub unsafe fn cmd_draw_mesh_tasks_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		group_count_x: u32,
		group_count_y: u32,
		group_count_z: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_draw_mesh_tasks_ext(
				self,
				command_buffer,
				group_count_x,
				group_count_y,
				group_count_z,
			)
		}
	}
}

/// Call `vkCmdDrawMeshTasksIndirectEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawMeshTasksIndirectEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDrawMeshTasksIndirectEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawMeshTasksIndirectEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawMeshTasksIndirectEXT.html)"]
pub unsafe fn cmd_draw_mesh_tasks_indirect_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	buffer: vk::Buffer,
	offset: vk::DeviceSize,
	draw_count: u32,
	stride: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_mesh_tasks_indirect_ext
		.ok_or(CallError::MissingCommand("vkCmdDrawMeshTasksIndirectEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, buffer, offset, draw_count, stride) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawMeshTasksIndirectEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawMeshTasksIndirectEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDrawMeshTasksIndirectEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawMeshTasksIndirectEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawMeshTasksIndirectEXT.html)"]
	#[inline]
	pub unsafe fn cmd_draw_mesh_tasks_indirect_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		buffer: vk::Buffer,
		offset: vk::DeviceSize,
		draw_count: u32,
		stride: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_draw_mesh_tasks_indirect_ext(self, command_buffer, buffer, offset, draw_count, stride)
		}
	}
}

/// Call `vkCmdDrawMeshTasksIndirectCountEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawMeshTasksIndirectCountEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDrawMeshTasksIndirectCountEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawMeshTasksIndirectCountEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawMeshTasksIndirectCountEXT.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_draw_mesh_tasks_indirect_count_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	buffer: vk::Buffer,
	offset: vk::DeviceSize,
	count_buffer: vk::Buffer,
	count_buffer_offset: vk::DeviceSize,
	max_draw_count: u32,
	stride: u32,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_draw_mesh_tasks_indirect_count_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdDrawMeshTasksIndirectCountEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			buffer,
			offset,
			count_buffer,
			count_buffer_offset,
			max_draw_count,
			stride,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawMeshTasksIndirectCountEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawMeshTasksIndirectCountEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDrawMeshTasksIndirectCountEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawMeshTasksIndirectCountEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawMeshTasksIndirectCountEXT.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_draw_mesh_tasks_indirect_count_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		buffer: vk::Buffer,
		offset: vk::DeviceSize,
		count_buffer: vk::Buffer,
		count_buffer_offset: vk::DeviceSize,
		max_draw_count: u32,
		stride: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_draw_mesh_tasks_indirect_count_ext(
				self,
				command_buffer,
				buffer,
				offset,
				count_buffer,
				count_buffer_offset,
				max_draw_count,
				stride,
			)
		}
	}
}

/// Call `vkCompileDeferredNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCompileDeferredNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCompileDeferredNV")]
#[doc = "\n\n[Khronos reference: `vkCompileDeferredNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCompileDeferredNV.html)"]
pub unsafe fn compile_deferred_nv(
	device: &Device,
	pipeline: vk::Pipeline,
	shader: u32,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.compile_deferred_nv
		.ok_or(CallError::MissingCommand("vkCompileDeferredNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), pipeline, shader) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCompileDeferredNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCompileDeferredNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCompileDeferredNV")]
	#[doc = "\n\n[Khronos reference: `vkCompileDeferredNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCompileDeferredNV.html)"]
	#[inline]
	pub unsafe fn compile_deferred_nv(
		&self,
		pipeline: vk::Pipeline,
		shader: u32,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { compile_deferred_nv(self, pipeline, shader) }
	}
}

/// Call `vkCreateAccelerationStructureNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateAccelerationStructureNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateAccelerationStructureNV")]
#[doc = "\n\n[Khronos reference: `vkCreateAccelerationStructureNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateAccelerationStructureNV.html)"]
pub unsafe fn create_acceleration_structure_nv(
	device: &Device,
	p_create_info: *const vk::AccelerationStructureCreateInfoNV<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_acceleration_structure: *mut vk::AccelerationStructureNV,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_acceleration_structure_nv
		.ok_or(CallError::MissingCommand("vkCreateAccelerationStructureNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_create_info,
			p_allocator,
			p_acceleration_structure,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateAccelerationStructureNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateAccelerationStructureNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateAccelerationStructureNV")]
	#[doc = "\n\n[Khronos reference: `vkCreateAccelerationStructureNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateAccelerationStructureNV.html)"]
	#[inline]
	pub unsafe fn create_acceleration_structure_nv(
		&self,
		p_create_info: *const vk::AccelerationStructureCreateInfoNV<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_acceleration_structure: *mut vk::AccelerationStructureNV,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			create_acceleration_structure_nv(self, p_create_info, p_allocator, p_acceleration_structure)
		}
	}
}

/// Call `vkCmdBindInvocationMaskHUAWEI` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindInvocationMaskHUAWEI` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBindInvocationMaskHUAWEI")]
#[doc = "\n\n[Khronos reference: `vkCmdBindInvocationMaskHUAWEI`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindInvocationMaskHUAWEI.html)"]
pub unsafe fn cmd_bind_invocation_mask_huawei(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	image_view: vk::ImageView,
	image_layout: vk::ImageLayout,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_invocation_mask_huawei
		.ok_or(CallError::MissingCommand("vkCmdBindInvocationMaskHUAWEI"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, image_view, image_layout) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBindInvocationMaskHUAWEI` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindInvocationMaskHUAWEI` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBindInvocationMaskHUAWEI")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindInvocationMaskHUAWEI`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindInvocationMaskHUAWEI.html)"]
	#[inline]
	pub unsafe fn cmd_bind_invocation_mask_huawei(
		&self,
		command_buffer: vk::CommandBuffer,
		image_view: vk::ImageView,
		image_layout: vk::ImageLayout,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_bind_invocation_mask_huawei(self, command_buffer, image_view, image_layout) }
	}
}

/// Call `vkDestroyAccelerationStructureKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyAccelerationStructureKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyAccelerationStructureKHR")]
#[doc = "\n\n[Khronos reference: `vkDestroyAccelerationStructureKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyAccelerationStructureKHR.html)"]
pub unsafe fn destroy_acceleration_structure_khr(
	device: &Device,
	acceleration_structure: vk::AccelerationStructureKHR,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.destroy_acceleration_structure_khr
			.ok_or(CallError::MissingCommand(
				"vkDestroyAccelerationStructureKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), acceleration_structure, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyAccelerationStructureKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyAccelerationStructureKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyAccelerationStructureKHR")]
	#[doc = "\n\n[Khronos reference: `vkDestroyAccelerationStructureKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyAccelerationStructureKHR.html)"]
	#[inline]
	pub unsafe fn destroy_acceleration_structure_khr(
		&self,
		acceleration_structure: vk::AccelerationStructureKHR,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_acceleration_structure_khr(self, acceleration_structure, p_allocator) }
	}
}

/// Call `vkDestroyAccelerationStructureNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyAccelerationStructureNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyAccelerationStructureNV")]
#[doc = "\n\n[Khronos reference: `vkDestroyAccelerationStructureNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyAccelerationStructureNV.html)"]
pub unsafe fn destroy_acceleration_structure_nv(
	device: &Device,
	acceleration_structure: vk::AccelerationStructureNV,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.destroy_acceleration_structure_nv
			.ok_or(CallError::MissingCommand(
				"vkDestroyAccelerationStructureNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), acceleration_structure, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyAccelerationStructureNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyAccelerationStructureNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyAccelerationStructureNV")]
	#[doc = "\n\n[Khronos reference: `vkDestroyAccelerationStructureNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyAccelerationStructureNV.html)"]
	#[inline]
	pub unsafe fn destroy_acceleration_structure_nv(
		&self,
		acceleration_structure: vk::AccelerationStructureNV,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_acceleration_structure_nv(self, acceleration_structure, p_allocator) }
	}
}

/// Call `vkGetAccelerationStructureMemoryRequirementsNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetAccelerationStructureMemoryRequirementsNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetAccelerationStructureMemoryRequirementsNV")]
#[doc = "\n\n[Khronos reference: `vkGetAccelerationStructureMemoryRequirementsNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetAccelerationStructureMemoryRequirementsNV.html)"]
pub unsafe fn get_acceleration_structure_memory_requirements_nv(
	device: &Device,
	p_info: *const vk::AccelerationStructureMemoryRequirementsInfoNV<'_>,
	p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_acceleration_structure_memory_requirements_nv
		.ok_or(CallError::MissingCommand(
			"vkGetAccelerationStructureMemoryRequirementsNV",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_info, p_memory_requirements) };
	Ok(())
}

impl Device {
	/// Call `vkGetAccelerationStructureMemoryRequirementsNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetAccelerationStructureMemoryRequirementsNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetAccelerationStructureMemoryRequirementsNV")]
	#[doc = "\n\n[Khronos reference: `vkGetAccelerationStructureMemoryRequirementsNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetAccelerationStructureMemoryRequirementsNV.html)"]
	#[inline]
	pub unsafe fn get_acceleration_structure_memory_requirements_nv(
		&self,
		p_info: *const vk::AccelerationStructureMemoryRequirementsInfoNV<'_>,
		p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_acceleration_structure_memory_requirements_nv(self, p_info, p_memory_requirements)
		}
	}
}

/// Call `vkBindAccelerationStructureMemoryNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkBindAccelerationStructureMemoryNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkBindAccelerationStructureMemoryNV")]
#[doc = "\n\n[Khronos reference: `vkBindAccelerationStructureMemoryNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBindAccelerationStructureMemoryNV.html)"]
pub unsafe fn bind_acceleration_structure_memory_nv(
	device: &Device,
	bind_info_count: u32,
	p_bind_infos: *const vk::BindAccelerationStructureMemoryInfoNV<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.bind_acceleration_structure_memory_nv
			.ok_or(CallError::MissingCommand(
				"vkBindAccelerationStructureMemoryNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), bind_info_count, p_bind_infos) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkBindAccelerationStructureMemoryNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkBindAccelerationStructureMemoryNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkBindAccelerationStructureMemoryNV")]
	#[doc = "\n\n[Khronos reference: `vkBindAccelerationStructureMemoryNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBindAccelerationStructureMemoryNV.html)"]
	#[inline]
	pub unsafe fn bind_acceleration_structure_memory_nv(
		&self,
		bind_info_count: u32,
		p_bind_infos: *const vk::BindAccelerationStructureMemoryInfoNV<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { bind_acceleration_structure_memory_nv(self, bind_info_count, p_bind_infos) }
	}
}

/// Call `vkCmdCopyAccelerationStructureNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyAccelerationStructureNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdCopyAccelerationStructureNV")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyAccelerationStructureNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyAccelerationStructureNV.html)"]
pub unsafe fn cmd_copy_acceleration_structure_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	dst: vk::AccelerationStructureNV,
	src: vk::AccelerationStructureNV,
	mode: vk::CopyAccelerationStructureModeKHR,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_copy_acceleration_structure_nv
			.ok_or(CallError::MissingCommand(
				"vkCmdCopyAccelerationStructureNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, dst, src, mode) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyAccelerationStructureNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyAccelerationStructureNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdCopyAccelerationStructureNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyAccelerationStructureNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyAccelerationStructureNV.html)"]
	#[inline]
	pub unsafe fn cmd_copy_acceleration_structure_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		dst: vk::AccelerationStructureNV,
		src: vk::AccelerationStructureNV,
		mode: vk::CopyAccelerationStructureModeKHR,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_acceleration_structure_nv(self, command_buffer, dst, src, mode) }
	}
}

/// Call `vkCmdCopyAccelerationStructureKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyAccelerationStructureKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdCopyAccelerationStructureKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyAccelerationStructureKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyAccelerationStructureKHR.html)"]
pub unsafe fn cmd_copy_acceleration_structure_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_info: *const vk::CopyAccelerationStructureInfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_copy_acceleration_structure_khr
			.ok_or(CallError::MissingCommand(
				"vkCmdCopyAccelerationStructureKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyAccelerationStructureKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyAccelerationStructureKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdCopyAccelerationStructureKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyAccelerationStructureKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyAccelerationStructureKHR.html)"]
	#[inline]
	pub unsafe fn cmd_copy_acceleration_structure_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_info: *const vk::CopyAccelerationStructureInfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_acceleration_structure_khr(self, command_buffer, p_info) }
	}
}

/// Call `vkCopyAccelerationStructureKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCopyAccelerationStructureKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCopyAccelerationStructureKHR")]
#[doc = "\n\n[Khronos reference: `vkCopyAccelerationStructureKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyAccelerationStructureKHR.html)"]
pub unsafe fn copy_acceleration_structure_khr(
	device: &Device,
	deferred_operation: vk::DeferredOperationKHR,
	p_info: *const vk::CopyAccelerationStructureInfoKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.copy_acceleration_structure_khr
		.ok_or(CallError::MissingCommand("vkCopyAccelerationStructureKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), deferred_operation, p_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCopyAccelerationStructureKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCopyAccelerationStructureKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCopyAccelerationStructureKHR")]
	#[doc = "\n\n[Khronos reference: `vkCopyAccelerationStructureKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyAccelerationStructureKHR.html)"]
	#[inline]
	pub unsafe fn copy_acceleration_structure_khr(
		&self,
		deferred_operation: vk::DeferredOperationKHR,
		p_info: *const vk::CopyAccelerationStructureInfoKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { copy_acceleration_structure_khr(self, deferred_operation, p_info) }
	}
}

/// Call `vkCmdCopyAccelerationStructureToMemoryKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyAccelerationStructureToMemoryKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdCopyAccelerationStructureToMemoryKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyAccelerationStructureToMemoryKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyAccelerationStructureToMemoryKHR.html)"]
pub unsafe fn cmd_copy_acceleration_structure_to_memory_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_info: *const vk::CopyAccelerationStructureToMemoryInfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_acceleration_structure_to_memory_khr
		.ok_or(CallError::MissingCommand(
			"vkCmdCopyAccelerationStructureToMemoryKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyAccelerationStructureToMemoryKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyAccelerationStructureToMemoryKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdCopyAccelerationStructureToMemoryKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyAccelerationStructureToMemoryKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyAccelerationStructureToMemoryKHR.html)"]
	#[inline]
	pub unsafe fn cmd_copy_acceleration_structure_to_memory_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_info: *const vk::CopyAccelerationStructureToMemoryInfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_acceleration_structure_to_memory_khr(self, command_buffer, p_info) }
	}
}

/// Call `vkCopyAccelerationStructureToMemoryKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCopyAccelerationStructureToMemoryKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCopyAccelerationStructureToMemoryKHR")]
#[doc = "\n\n[Khronos reference: `vkCopyAccelerationStructureToMemoryKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyAccelerationStructureToMemoryKHR.html)"]
pub unsafe fn copy_acceleration_structure_to_memory_khr(
	device: &Device,
	deferred_operation: vk::DeferredOperationKHR,
	p_info: *const vk::CopyAccelerationStructureToMemoryInfoKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.copy_acceleration_structure_to_memory_khr
		.ok_or(CallError::MissingCommand(
			"vkCopyAccelerationStructureToMemoryKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), deferred_operation, p_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCopyAccelerationStructureToMemoryKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCopyAccelerationStructureToMemoryKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCopyAccelerationStructureToMemoryKHR")]
	#[doc = "\n\n[Khronos reference: `vkCopyAccelerationStructureToMemoryKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyAccelerationStructureToMemoryKHR.html)"]
	#[inline]
	pub unsafe fn copy_acceleration_structure_to_memory_khr(
		&self,
		deferred_operation: vk::DeferredOperationKHR,
		p_info: *const vk::CopyAccelerationStructureToMemoryInfoKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { copy_acceleration_structure_to_memory_khr(self, deferred_operation, p_info) }
	}
}

/// Call `vkCmdCopyMemoryToAccelerationStructureKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyMemoryToAccelerationStructureKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdCopyMemoryToAccelerationStructureKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyMemoryToAccelerationStructureKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyMemoryToAccelerationStructureKHR.html)"]
pub unsafe fn cmd_copy_memory_to_acceleration_structure_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_info: *const vk::CopyMemoryToAccelerationStructureInfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_memory_to_acceleration_structure_khr
		.ok_or(CallError::MissingCommand(
			"vkCmdCopyMemoryToAccelerationStructureKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyMemoryToAccelerationStructureKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyMemoryToAccelerationStructureKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdCopyMemoryToAccelerationStructureKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyMemoryToAccelerationStructureKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyMemoryToAccelerationStructureKHR.html)"]
	#[inline]
	pub unsafe fn cmd_copy_memory_to_acceleration_structure_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_info: *const vk::CopyMemoryToAccelerationStructureInfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_memory_to_acceleration_structure_khr(self, command_buffer, p_info) }
	}
}

/// Call `vkCopyMemoryToAccelerationStructureKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCopyMemoryToAccelerationStructureKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCopyMemoryToAccelerationStructureKHR")]
#[doc = "\n\n[Khronos reference: `vkCopyMemoryToAccelerationStructureKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyMemoryToAccelerationStructureKHR.html)"]
pub unsafe fn copy_memory_to_acceleration_structure_khr(
	device: &Device,
	deferred_operation: vk::DeferredOperationKHR,
	p_info: *const vk::CopyMemoryToAccelerationStructureInfoKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.copy_memory_to_acceleration_structure_khr
		.ok_or(CallError::MissingCommand(
			"vkCopyMemoryToAccelerationStructureKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), deferred_operation, p_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCopyMemoryToAccelerationStructureKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCopyMemoryToAccelerationStructureKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCopyMemoryToAccelerationStructureKHR")]
	#[doc = "\n\n[Khronos reference: `vkCopyMemoryToAccelerationStructureKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyMemoryToAccelerationStructureKHR.html)"]
	#[inline]
	pub unsafe fn copy_memory_to_acceleration_structure_khr(
		&self,
		deferred_operation: vk::DeferredOperationKHR,
		p_info: *const vk::CopyMemoryToAccelerationStructureInfoKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { copy_memory_to_acceleration_structure_khr(self, deferred_operation, p_info) }
	}
}

/// Call `vkCmdWriteAccelerationStructuresPropertiesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdWriteAccelerationStructuresPropertiesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdWriteAccelerationStructuresPropertiesKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdWriteAccelerationStructuresPropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWriteAccelerationStructuresPropertiesKHR.html)"]
pub unsafe fn cmd_write_acceleration_structures_properties_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	acceleration_structure_count: u32,
	p_acceleration_structures: *const vk::AccelerationStructureKHR,
	query_type: vk::QueryType,
	query_pool: vk::QueryPool,
	first_query: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_write_acceleration_structures_properties_khr
		.ok_or(CallError::MissingCommand(
			"vkCmdWriteAccelerationStructuresPropertiesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			acceleration_structure_count,
			p_acceleration_structures,
			query_type,
			query_pool,
			first_query,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdWriteAccelerationStructuresPropertiesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdWriteAccelerationStructuresPropertiesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdWriteAccelerationStructuresPropertiesKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdWriteAccelerationStructuresPropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWriteAccelerationStructuresPropertiesKHR.html)"]
	#[inline]
	pub unsafe fn cmd_write_acceleration_structures_properties_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		acceleration_structure_count: u32,
		p_acceleration_structures: *const vk::AccelerationStructureKHR,
		query_type: vk::QueryType,
		query_pool: vk::QueryPool,
		first_query: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_write_acceleration_structures_properties_khr(
				self,
				command_buffer,
				acceleration_structure_count,
				p_acceleration_structures,
				query_type,
				query_pool,
				first_query,
			)
		}
	}
}

/// Call `vkCmdWriteAccelerationStructuresPropertiesNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdWriteAccelerationStructuresPropertiesNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdWriteAccelerationStructuresPropertiesNV")]
#[doc = "\n\n[Khronos reference: `vkCmdWriteAccelerationStructuresPropertiesNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWriteAccelerationStructuresPropertiesNV.html)"]
pub unsafe fn cmd_write_acceleration_structures_properties_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	acceleration_structure_count: u32,
	p_acceleration_structures: *const vk::AccelerationStructureNV,
	query_type: vk::QueryType,
	query_pool: vk::QueryPool,
	first_query: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_write_acceleration_structures_properties_nv
		.ok_or(CallError::MissingCommand(
			"vkCmdWriteAccelerationStructuresPropertiesNV",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			acceleration_structure_count,
			p_acceleration_structures,
			query_type,
			query_pool,
			first_query,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdWriteAccelerationStructuresPropertiesNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdWriteAccelerationStructuresPropertiesNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdWriteAccelerationStructuresPropertiesNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdWriteAccelerationStructuresPropertiesNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWriteAccelerationStructuresPropertiesNV.html)"]
	#[inline]
	pub unsafe fn cmd_write_acceleration_structures_properties_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		acceleration_structure_count: u32,
		p_acceleration_structures: *const vk::AccelerationStructureNV,
		query_type: vk::QueryType,
		query_pool: vk::QueryPool,
		first_query: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_write_acceleration_structures_properties_nv(
				self,
				command_buffer,
				acceleration_structure_count,
				p_acceleration_structures,
				query_type,
				query_pool,
				first_query,
			)
		}
	}
}

/// Call `vkCmdBuildAccelerationStructureNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBuildAccelerationStructureNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBuildAccelerationStructureNV")]
#[doc = "\n\n[Khronos reference: `vkCmdBuildAccelerationStructureNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBuildAccelerationStructureNV.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_build_acceleration_structure_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_info: *const vk::AccelerationStructureInfoNV<'_>,
	instance_data: vk::Buffer,
	instance_offset: vk::DeviceSize,
	update: vk::Bool32,
	dst: vk::AccelerationStructureNV,
	src: vk::AccelerationStructureNV,
	scratch: vk::Buffer,
	scratch_offset: vk::DeviceSize,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_build_acceleration_structure_nv
			.ok_or(CallError::MissingCommand(
				"vkCmdBuildAccelerationStructureNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			p_info,
			instance_data,
			instance_offset,
			update,
			dst,
			src,
			scratch,
			scratch_offset,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdBuildAccelerationStructureNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBuildAccelerationStructureNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBuildAccelerationStructureNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdBuildAccelerationStructureNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBuildAccelerationStructureNV.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_build_acceleration_structure_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		p_info: *const vk::AccelerationStructureInfoNV<'_>,
		instance_data: vk::Buffer,
		instance_offset: vk::DeviceSize,
		update: vk::Bool32,
		dst: vk::AccelerationStructureNV,
		src: vk::AccelerationStructureNV,
		scratch: vk::Buffer,
		scratch_offset: vk::DeviceSize,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_build_acceleration_structure_nv(
				self,
				command_buffer,
				p_info,
				instance_data,
				instance_offset,
				update,
				dst,
				src,
				scratch,
				scratch_offset,
			)
		}
	}
}

/// Call `vkWriteAccelerationStructuresPropertiesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkWriteAccelerationStructuresPropertiesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkWriteAccelerationStructuresPropertiesKHR")]
#[doc = "\n\n[Khronos reference: `vkWriteAccelerationStructuresPropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkWriteAccelerationStructuresPropertiesKHR.html)"]
pub unsafe fn write_acceleration_structures_properties_khr(
	device: &Device,
	acceleration_structure_count: u32,
	p_acceleration_structures: *const vk::AccelerationStructureKHR,
	query_type: vk::QueryType,
	data_size: usize,
	p_data: *mut std::ffi::c_void,
	stride: usize,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.write_acceleration_structures_properties_khr
		.ok_or(CallError::MissingCommand(
			"vkWriteAccelerationStructuresPropertiesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			acceleration_structure_count,
			p_acceleration_structures,
			query_type,
			data_size,
			p_data,
			stride,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkWriteAccelerationStructuresPropertiesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkWriteAccelerationStructuresPropertiesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkWriteAccelerationStructuresPropertiesKHR")]
	#[doc = "\n\n[Khronos reference: `vkWriteAccelerationStructuresPropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkWriteAccelerationStructuresPropertiesKHR.html)"]
	#[inline]
	pub unsafe fn write_acceleration_structures_properties_khr(
		&self,
		acceleration_structure_count: u32,
		p_acceleration_structures: *const vk::AccelerationStructureKHR,
		query_type: vk::QueryType,
		data_size: usize,
		p_data: *mut std::ffi::c_void,
		stride: usize,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			write_acceleration_structures_properties_khr(
				self,
				acceleration_structure_count,
				p_acceleration_structures,
				query_type,
				data_size,
				p_data,
				stride,
			)
		}
	}
}

/// Call `vkCmdTraceRaysKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdTraceRaysKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdTraceRaysKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdTraceRaysKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdTraceRaysKHR.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_trace_rays_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_raygen_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
	p_miss_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
	p_hit_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
	p_callable_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
	width: u32,
	height: u32,
	depth: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_trace_rays_khr
		.ok_or(CallError::MissingCommand("vkCmdTraceRaysKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			p_raygen_shader_binding_table,
			p_miss_shader_binding_table,
			p_hit_shader_binding_table,
			p_callable_shader_binding_table,
			width,
			height,
			depth,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdTraceRaysKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdTraceRaysKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdTraceRaysKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdTraceRaysKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdTraceRaysKHR.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_trace_rays_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_raygen_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
		p_miss_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
		p_hit_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
		p_callable_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
		width: u32,
		height: u32,
		depth: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_trace_rays_khr(
				self,
				command_buffer,
				p_raygen_shader_binding_table,
				p_miss_shader_binding_table,
				p_hit_shader_binding_table,
				p_callable_shader_binding_table,
				width,
				height,
				depth,
			)
		}
	}
}

/// Call `vkCmdTraceRaysNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdTraceRaysNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdTraceRaysNV")]
#[doc = "\n\n[Khronos reference: `vkCmdTraceRaysNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdTraceRaysNV.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_trace_rays_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	raygen_shader_binding_table_buffer: vk::Buffer,
	raygen_shader_binding_offset: vk::DeviceSize,
	miss_shader_binding_table_buffer: vk::Buffer,
	miss_shader_binding_offset: vk::DeviceSize,
	miss_shader_binding_stride: vk::DeviceSize,
	hit_shader_binding_table_buffer: vk::Buffer,
	hit_shader_binding_offset: vk::DeviceSize,
	hit_shader_binding_stride: vk::DeviceSize,
	callable_shader_binding_table_buffer: vk::Buffer,
	callable_shader_binding_offset: vk::DeviceSize,
	callable_shader_binding_stride: vk::DeviceSize,
	width: u32,
	height: u32,
	depth: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_trace_rays_nv
		.ok_or(CallError::MissingCommand("vkCmdTraceRaysNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			raygen_shader_binding_table_buffer,
			raygen_shader_binding_offset,
			miss_shader_binding_table_buffer,
			miss_shader_binding_offset,
			miss_shader_binding_stride,
			hit_shader_binding_table_buffer,
			hit_shader_binding_offset,
			hit_shader_binding_stride,
			callable_shader_binding_table_buffer,
			callable_shader_binding_offset,
			callable_shader_binding_stride,
			width,
			height,
			depth,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdTraceRaysNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdTraceRaysNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdTraceRaysNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdTraceRaysNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdTraceRaysNV.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_trace_rays_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		raygen_shader_binding_table_buffer: vk::Buffer,
		raygen_shader_binding_offset: vk::DeviceSize,
		miss_shader_binding_table_buffer: vk::Buffer,
		miss_shader_binding_offset: vk::DeviceSize,
		miss_shader_binding_stride: vk::DeviceSize,
		hit_shader_binding_table_buffer: vk::Buffer,
		hit_shader_binding_offset: vk::DeviceSize,
		hit_shader_binding_stride: vk::DeviceSize,
		callable_shader_binding_table_buffer: vk::Buffer,
		callable_shader_binding_offset: vk::DeviceSize,
		callable_shader_binding_stride: vk::DeviceSize,
		width: u32,
		height: u32,
		depth: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_trace_rays_nv(
				self,
				command_buffer,
				raygen_shader_binding_table_buffer,
				raygen_shader_binding_offset,
				miss_shader_binding_table_buffer,
				miss_shader_binding_offset,
				miss_shader_binding_stride,
				hit_shader_binding_table_buffer,
				hit_shader_binding_offset,
				hit_shader_binding_stride,
				callable_shader_binding_table_buffer,
				callable_shader_binding_offset,
				callable_shader_binding_stride,
				width,
				height,
				depth,
			)
		}
	}
}

/// Call `vkGetRayTracingShaderGroupHandlesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetRayTracingShaderGroupHandlesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetRayTracingShaderGroupHandlesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetRayTracingShaderGroupHandlesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetRayTracingShaderGroupHandlesKHR.html)"]
pub unsafe fn get_ray_tracing_shader_group_handles_khr(
	device: &Device,
	pipeline: vk::Pipeline,
	first_group: u32,
	group_count: u32,
	data_size: usize,
	p_data: *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.get_ray_tracing_shader_group_handles_khr
			.ok_or(CallError::MissingCommand(
				"vkGetRayTracingShaderGroupHandlesKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			pipeline,
			first_group,
			group_count,
			data_size,
			p_data,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetRayTracingShaderGroupHandlesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetRayTracingShaderGroupHandlesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetRayTracingShaderGroupHandlesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetRayTracingShaderGroupHandlesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetRayTracingShaderGroupHandlesKHR.html)"]
	#[inline]
	pub unsafe fn get_ray_tracing_shader_group_handles_khr(
		&self,
		pipeline: vk::Pipeline,
		first_group: u32,
		group_count: u32,
		data_size: usize,
		p_data: *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_ray_tracing_shader_group_handles_khr(
				self,
				pipeline,
				first_group,
				group_count,
				data_size,
				p_data,
			)
		}
	}
}

/// Call `vkGetRayTracingShaderGroupHandlesNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetRayTracingShaderGroupHandlesNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetRayTracingShaderGroupHandlesNV")]
#[doc = "\n\n[Khronos reference: `vkGetRayTracingShaderGroupHandlesNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetRayTracingShaderGroupHandlesNV.html)"]
pub unsafe fn get_ray_tracing_shader_group_handles_nv(
	device: &Device,
	pipeline: vk::Pipeline,
	first_group: u32,
	group_count: u32,
	data_size: usize,
	p_data: *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.get_ray_tracing_shader_group_handles_nv
			.ok_or(CallError::MissingCommand(
				"vkGetRayTracingShaderGroupHandlesNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			pipeline,
			first_group,
			group_count,
			data_size,
			p_data,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetRayTracingShaderGroupHandlesNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetRayTracingShaderGroupHandlesNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetRayTracingShaderGroupHandlesNV")]
	#[doc = "\n\n[Khronos reference: `vkGetRayTracingShaderGroupHandlesNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetRayTracingShaderGroupHandlesNV.html)"]
	#[inline]
	pub unsafe fn get_ray_tracing_shader_group_handles_nv(
		&self,
		pipeline: vk::Pipeline,
		first_group: u32,
		group_count: u32,
		data_size: usize,
		p_data: *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_ray_tracing_shader_group_handles_nv(
				self,
				pipeline,
				first_group,
				group_count,
				data_size,
				p_data,
			)
		}
	}
}

/// Call `vkGetRayTracingCaptureReplayShaderGroupHandlesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetRayTracingCaptureReplayShaderGroupHandlesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetRayTracingCaptureReplayShaderGroupHandlesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html)"]
pub unsafe fn get_ray_tracing_capture_replay_shader_group_handles_khr(
	device: &Device,
	pipeline: vk::Pipeline,
	first_group: u32,
	group_count: u32,
	data_size: usize,
	p_data: *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_ray_tracing_capture_replay_shader_group_handles_khr
		.ok_or(CallError::MissingCommand(
			"vkGetRayTracingCaptureReplayShaderGroupHandlesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			pipeline,
			first_group,
			group_count,
			data_size,
			p_data,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetRayTracingCaptureReplayShaderGroupHandlesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetRayTracingCaptureReplayShaderGroupHandlesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetRayTracingCaptureReplayShaderGroupHandlesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html)"]
	#[inline]
	pub unsafe fn get_ray_tracing_capture_replay_shader_group_handles_khr(
		&self,
		pipeline: vk::Pipeline,
		first_group: u32,
		group_count: u32,
		data_size: usize,
		p_data: *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_ray_tracing_capture_replay_shader_group_handles_khr(
				self,
				pipeline,
				first_group,
				group_count,
				data_size,
				p_data,
			)
		}
	}
}

/// Call `vkGetAccelerationStructureHandleNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetAccelerationStructureHandleNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetAccelerationStructureHandleNV")]
#[doc = "\n\n[Khronos reference: `vkGetAccelerationStructureHandleNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetAccelerationStructureHandleNV.html)"]
pub unsafe fn get_acceleration_structure_handle_nv(
	device: &Device,
	acceleration_structure: vk::AccelerationStructureNV,
	data_size: usize,
	p_data: *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.get_acceleration_structure_handle_nv
			.ok_or(CallError::MissingCommand(
				"vkGetAccelerationStructureHandleNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), acceleration_structure, data_size, p_data) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetAccelerationStructureHandleNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetAccelerationStructureHandleNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetAccelerationStructureHandleNV")]
	#[doc = "\n\n[Khronos reference: `vkGetAccelerationStructureHandleNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetAccelerationStructureHandleNV.html)"]
	#[inline]
	pub unsafe fn get_acceleration_structure_handle_nv(
		&self,
		acceleration_structure: vk::AccelerationStructureNV,
		data_size: usize,
		p_data: *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_acceleration_structure_handle_nv(self, acceleration_structure, data_size, p_data) }
	}
}

/// Call `vkCreateRayTracingPipelinesNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateRayTracingPipelinesNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateRayTracingPipelinesNV")]
#[doc = "\n\n[Khronos reference: `vkCreateRayTracingPipelinesNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateRayTracingPipelinesNV.html)"]
pub unsafe fn create_ray_tracing_pipelines_nv(
	device: &Device,
	pipeline_cache: vk::PipelineCache,
	create_info_count: u32,
	p_create_infos: *const vk::RayTracingPipelineCreateInfoNV<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_pipelines: *mut vk::Pipeline,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_ray_tracing_pipelines_nv
		.ok_or(CallError::MissingCommand("vkCreateRayTracingPipelinesNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			pipeline_cache,
			create_info_count,
			p_create_infos,
			p_allocator,
			p_pipelines,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateRayTracingPipelinesNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateRayTracingPipelinesNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateRayTracingPipelinesNV")]
	#[doc = "\n\n[Khronos reference: `vkCreateRayTracingPipelinesNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateRayTracingPipelinesNV.html)"]
	#[inline]
	pub unsafe fn create_ray_tracing_pipelines_nv(
		&self,
		pipeline_cache: vk::PipelineCache,
		create_info_count: u32,
		p_create_infos: *const vk::RayTracingPipelineCreateInfoNV<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_pipelines: *mut vk::Pipeline,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			create_ray_tracing_pipelines_nv(
				self,
				pipeline_cache,
				create_info_count,
				p_create_infos,
				p_allocator,
				p_pipelines,
			)
		}
	}
}

/// Call `vkCreateRayTracingPipelinesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateRayTracingPipelinesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateRayTracingPipelinesKHR")]
#[doc = "\n\n[Khronos reference: `vkCreateRayTracingPipelinesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateRayTracingPipelinesKHR.html)"]
pub unsafe fn create_ray_tracing_pipelines_khr(
	device: &Device,
	deferred_operation: vk::DeferredOperationKHR,
	pipeline_cache: vk::PipelineCache,
	create_info_count: u32,
	p_create_infos: *const vk::RayTracingPipelineCreateInfoKHR<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_pipelines: *mut vk::Pipeline,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_ray_tracing_pipelines_khr
		.ok_or(CallError::MissingCommand("vkCreateRayTracingPipelinesKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			deferred_operation,
			pipeline_cache,
			create_info_count,
			p_create_infos,
			p_allocator,
			p_pipelines,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateRayTracingPipelinesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateRayTracingPipelinesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateRayTracingPipelinesKHR")]
	#[doc = "\n\n[Khronos reference: `vkCreateRayTracingPipelinesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateRayTracingPipelinesKHR.html)"]
	#[inline]
	pub unsafe fn create_ray_tracing_pipelines_khr(
		&self,
		deferred_operation: vk::DeferredOperationKHR,
		pipeline_cache: vk::PipelineCache,
		create_info_count: u32,
		p_create_infos: *const vk::RayTracingPipelineCreateInfoKHR<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_pipelines: *mut vk::Pipeline,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			create_ray_tracing_pipelines_khr(
				self,
				deferred_operation,
				pipeline_cache,
				create_info_count,
				p_create_infos,
				p_allocator,
				p_pipelines,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceCooperativeMatrixPropertiesNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceCooperativeMatrixPropertiesNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceCooperativeMatrixPropertiesNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html)"]
pub unsafe fn get_physical_device_cooperative_matrix_properties_nv(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_property_count: *mut u32,
	p_properties: *mut vk::CooperativeMatrixPropertiesNV<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_cooperative_matrix_properties_nv
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, p_property_count, p_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceCooperativeMatrixPropertiesNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceCooperativeMatrixPropertiesNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceCooperativeMatrixPropertiesNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html)"]
	#[inline]
	pub unsafe fn get_physical_device_cooperative_matrix_properties_nv(
		&self,
		physical_device: vk::PhysicalDevice,
		p_property_count: *mut u32,
		p_properties: *mut vk::CooperativeMatrixPropertiesNV<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_cooperative_matrix_properties_nv(
				self,
				physical_device,
				p_property_count,
				p_properties,
			)
		}
	}
}

/// Call `vkCmdTraceRaysIndirectKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdTraceRaysIndirectKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdTraceRaysIndirectKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdTraceRaysIndirectKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdTraceRaysIndirectKHR.html)"]
pub unsafe fn cmd_trace_rays_indirect_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_raygen_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
	p_miss_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
	p_hit_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
	p_callable_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
	indirect_device_address: vk::DeviceAddress,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_trace_rays_indirect_khr
		.ok_or(CallError::MissingCommand("vkCmdTraceRaysIndirectKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			p_raygen_shader_binding_table,
			p_miss_shader_binding_table,
			p_hit_shader_binding_table,
			p_callable_shader_binding_table,
			indirect_device_address,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdTraceRaysIndirectKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdTraceRaysIndirectKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdTraceRaysIndirectKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdTraceRaysIndirectKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdTraceRaysIndirectKHR.html)"]
	#[inline]
	pub unsafe fn cmd_trace_rays_indirect_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_raygen_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
		p_miss_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
		p_hit_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
		p_callable_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
		indirect_device_address: vk::DeviceAddress,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_trace_rays_indirect_khr(
				self,
				command_buffer,
				p_raygen_shader_binding_table,
				p_miss_shader_binding_table,
				p_hit_shader_binding_table,
				p_callable_shader_binding_table,
				indirect_device_address,
			)
		}
	}
}

/// Call `vkCmdTraceRaysIndirect2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdTraceRaysIndirect2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdTraceRaysIndirect2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdTraceRaysIndirect2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdTraceRaysIndirect2KHR.html)"]
pub unsafe fn cmd_trace_rays_indirect2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	indirect_device_address: vk::DeviceAddress,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_trace_rays_indirect2_khr
		.ok_or(CallError::MissingCommand("vkCmdTraceRaysIndirect2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, indirect_device_address) };
	Ok(())
}

impl Device {
	/// Call `vkCmdTraceRaysIndirect2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdTraceRaysIndirect2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdTraceRaysIndirect2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdTraceRaysIndirect2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdTraceRaysIndirect2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_trace_rays_indirect2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		indirect_device_address: vk::DeviceAddress,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_trace_rays_indirect2_khr(self, command_buffer, indirect_device_address) }
	}
}

/// Call `vkGetClusterAccelerationStructureBuildSizesNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetClusterAccelerationStructureBuildSizesNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetClusterAccelerationStructureBuildSizesNV")]
#[doc = "\n\n[Khronos reference: `vkGetClusterAccelerationStructureBuildSizesNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetClusterAccelerationStructureBuildSizesNV.html)"]
pub unsafe fn get_cluster_acceleration_structure_build_sizes_nv(
	device: &Device,
	p_info: *const vk::ClusterAccelerationStructureInputInfoNV<'_>,
	p_size_info: *mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_cluster_acceleration_structure_build_sizes_nv
		.ok_or(CallError::MissingCommand(
			"vkGetClusterAccelerationStructureBuildSizesNV",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_info, p_size_info) };
	Ok(())
}

impl Device {
	/// Call `vkGetClusterAccelerationStructureBuildSizesNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetClusterAccelerationStructureBuildSizesNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetClusterAccelerationStructureBuildSizesNV")]
	#[doc = "\n\n[Khronos reference: `vkGetClusterAccelerationStructureBuildSizesNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetClusterAccelerationStructureBuildSizesNV.html)"]
	#[inline]
	pub unsafe fn get_cluster_acceleration_structure_build_sizes_nv(
		&self,
		p_info: *const vk::ClusterAccelerationStructureInputInfoNV<'_>,
		p_size_info: *mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_cluster_acceleration_structure_build_sizes_nv(self, p_info, p_size_info) }
	}
}

/// Call `vkCmdBuildClusterAccelerationStructureIndirectNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBuildClusterAccelerationStructureIndirectNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBuildClusterAccelerationStructureIndirectNV")]
#[doc = "\n\n[Khronos reference: `vkCmdBuildClusterAccelerationStructureIndirectNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBuildClusterAccelerationStructureIndirectNV.html)"]
pub unsafe fn cmd_build_cluster_acceleration_structure_indirect_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_command_infos: *const vk::ClusterAccelerationStructureCommandsInfoNV<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_build_cluster_acceleration_structure_indirect_nv
		.ok_or(CallError::MissingCommand(
			"vkCmdBuildClusterAccelerationStructureIndirectNV",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_command_infos) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBuildClusterAccelerationStructureIndirectNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBuildClusterAccelerationStructureIndirectNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBuildClusterAccelerationStructureIndirectNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdBuildClusterAccelerationStructureIndirectNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBuildClusterAccelerationStructureIndirectNV.html)"]
	#[inline]
	pub unsafe fn cmd_build_cluster_acceleration_structure_indirect_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		p_command_infos: *const vk::ClusterAccelerationStructureCommandsInfoNV<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_build_cluster_acceleration_structure_indirect_nv(self, command_buffer, p_command_infos)
		}
	}
}

/// Call `vkGetDeviceAccelerationStructureCompatibilityKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceAccelerationStructureCompatibilityKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeviceAccelerationStructureCompatibilityKHR")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceAccelerationStructureCompatibilityKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceAccelerationStructureCompatibilityKHR.html)"]
pub unsafe fn get_device_acceleration_structure_compatibility_khr(
	device: &Device,
	p_version_info: *const vk::AccelerationStructureVersionInfoKHR<'_>,
	p_compatibility: *mut vk::AccelerationStructureCompatibilityKHR,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_device_acceleration_structure_compatibility_khr
		.ok_or(CallError::MissingCommand(
			"vkGetDeviceAccelerationStructureCompatibilityKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_version_info, p_compatibility) };
	Ok(())
}

impl Device {
	/// Call `vkGetDeviceAccelerationStructureCompatibilityKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceAccelerationStructureCompatibilityKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeviceAccelerationStructureCompatibilityKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceAccelerationStructureCompatibilityKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceAccelerationStructureCompatibilityKHR.html)"]
	#[inline]
	pub unsafe fn get_device_acceleration_structure_compatibility_khr(
		&self,
		p_version_info: *const vk::AccelerationStructureVersionInfoKHR<'_>,
		p_compatibility: *mut vk::AccelerationStructureCompatibilityKHR,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_device_acceleration_structure_compatibility_khr(self, p_version_info, p_compatibility)
		}
	}
}

/// Call `vkGetRayTracingShaderGroupStackSizeKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetRayTracingShaderGroupStackSizeKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetRayTracingShaderGroupStackSizeKHR")]
#[doc = "\n\n[Khronos reference: `vkGetRayTracingShaderGroupStackSizeKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetRayTracingShaderGroupStackSizeKHR.html)"]
pub unsafe fn get_ray_tracing_shader_group_stack_size_khr(
	device: &Device,
	pipeline: vk::Pipeline,
	group: u32,
	group_shader: vk::ShaderGroupShaderKHR,
) -> Result<vk::DeviceSize, CallError> {
	let __vk_function = device
		.fp()
		.get_ray_tracing_shader_group_stack_size_khr
		.ok_or(CallError::MissingCommand(
			"vkGetRayTracingShaderGroupStackSizeKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), pipeline, group, group_shader) };
	Ok(result)
}

impl Device {
	/// Call `vkGetRayTracingShaderGroupStackSizeKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetRayTracingShaderGroupStackSizeKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetRayTracingShaderGroupStackSizeKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetRayTracingShaderGroupStackSizeKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetRayTracingShaderGroupStackSizeKHR.html)"]
	#[inline]
	pub unsafe fn get_ray_tracing_shader_group_stack_size_khr(
		&self,
		pipeline: vk::Pipeline,
		group: u32,
		group_shader: vk::ShaderGroupShaderKHR,
	) -> Result<vk::DeviceSize, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_ray_tracing_shader_group_stack_size_khr(self, pipeline, group, group_shader) }
	}
}

/// Call `vkCmdSetRayTracingPipelineStackSizeKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetRayTracingPipelineStackSizeKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetRayTracingPipelineStackSizeKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdSetRayTracingPipelineStackSizeKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetRayTracingPipelineStackSizeKHR.html)"]
pub unsafe fn cmd_set_ray_tracing_pipeline_stack_size_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	pipeline_stack_size: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_ray_tracing_pipeline_stack_size_khr
		.ok_or(CallError::MissingCommand(
			"vkCmdSetRayTracingPipelineStackSizeKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, pipeline_stack_size) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetRayTracingPipelineStackSizeKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetRayTracingPipelineStackSizeKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetRayTracingPipelineStackSizeKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetRayTracingPipelineStackSizeKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetRayTracingPipelineStackSizeKHR.html)"]
	#[inline]
	pub unsafe fn cmd_set_ray_tracing_pipeline_stack_size_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		pipeline_stack_size: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_ray_tracing_pipeline_stack_size_khr(self, command_buffer, pipeline_stack_size)
		}
	}
}

/// Call `vkGetImageViewHandleNVX` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetImageViewHandleNVX` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetImageViewHandleNVX")]
#[doc = "\n\n[Khronos reference: `vkGetImageViewHandleNVX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageViewHandleNVX.html)"]
pub unsafe fn get_image_view_handle_nvx(
	device: &Device,
	p_info: *const vk::ImageViewHandleInfoNVX<'_>,
) -> Result<u32, CallError> {
	let __vk_function = device
		.fp()
		.get_image_view_handle_nvx
		.ok_or(CallError::MissingCommand("vkGetImageViewHandleNVX"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_info) };
	Ok(result)
}

impl Device {
	/// Call `vkGetImageViewHandleNVX` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetImageViewHandleNVX` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetImageViewHandleNVX")]
	#[doc = "\n\n[Khronos reference: `vkGetImageViewHandleNVX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageViewHandleNVX.html)"]
	#[inline]
	pub unsafe fn get_image_view_handle_nvx(
		&self,
		p_info: *const vk::ImageViewHandleInfoNVX<'_>,
	) -> Result<u32, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_image_view_handle_nvx(self, p_info) }
	}
}

/// Call `vkGetImageViewHandle64NVX` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetImageViewHandle64NVX` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetImageViewHandle64NVX")]
#[doc = "\n\n[Khronos reference: `vkGetImageViewHandle64NVX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageViewHandle64NVX.html)"]
pub unsafe fn get_image_view_handle64_nvx(
	device: &Device,
	p_info: *const vk::ImageViewHandleInfoNVX<'_>,
) -> Result<u64, CallError> {
	let __vk_function = device
		.fp()
		.get_image_view_handle64_nvx
		.ok_or(CallError::MissingCommand("vkGetImageViewHandle64NVX"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_info) };
	Ok(result)
}

impl Device {
	/// Call `vkGetImageViewHandle64NVX` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetImageViewHandle64NVX` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetImageViewHandle64NVX")]
	#[doc = "\n\n[Khronos reference: `vkGetImageViewHandle64NVX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageViewHandle64NVX.html)"]
	#[inline]
	pub unsafe fn get_image_view_handle64_nvx(
		&self,
		p_info: *const vk::ImageViewHandleInfoNVX<'_>,
	) -> Result<u64, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_image_view_handle64_nvx(self, p_info) }
	}
}

/// Call `vkGetImageViewAddressNVX` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetImageViewAddressNVX` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetImageViewAddressNVX")]
#[doc = "\n\n[Khronos reference: `vkGetImageViewAddressNVX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageViewAddressNVX.html)"]
pub unsafe fn get_image_view_address_nvx(
	device: &Device,
	image_view: vk::ImageView,
	p_properties: *mut vk::ImageViewAddressPropertiesNVX<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_image_view_address_nvx
		.ok_or(CallError::MissingCommand("vkGetImageViewAddressNVX"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), image_view, p_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetImageViewAddressNVX` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetImageViewAddressNVX` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetImageViewAddressNVX")]
	#[doc = "\n\n[Khronos reference: `vkGetImageViewAddressNVX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageViewAddressNVX.html)"]
	#[inline]
	pub unsafe fn get_image_view_address_nvx(
		&self,
		image_view: vk::ImageView,
		p_properties: *mut vk::ImageViewAddressPropertiesNVX<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_image_view_address_nvx(self, image_view, p_properties) }
	}
}

/// Call `vkGetDeviceCombinedImageSamplerIndexNVX` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceCombinedImageSamplerIndexNVX` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeviceCombinedImageSamplerIndexNVX")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceCombinedImageSamplerIndexNVX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceCombinedImageSamplerIndexNVX.html)"]
pub unsafe fn get_device_combined_image_sampler_index_nvx(
	device: &Device,
	image_view_index: u64,
	sampler_index: u64,
) -> Result<u64, CallError> {
	let __vk_function = device
		.fp()
		.get_device_combined_image_sampler_index_nvx
		.ok_or(CallError::MissingCommand(
			"vkGetDeviceCombinedImageSamplerIndexNVX",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), image_view_index, sampler_index) };
	Ok(result)
}

impl Device {
	/// Call `vkGetDeviceCombinedImageSamplerIndexNVX` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceCombinedImageSamplerIndexNVX` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeviceCombinedImageSamplerIndexNVX")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceCombinedImageSamplerIndexNVX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceCombinedImageSamplerIndexNVX.html)"]
	#[inline]
	pub unsafe fn get_device_combined_image_sampler_index_nvx(
		&self,
		image_view_index: u64,
		sampler_index: u64,
	) -> Result<u64, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_device_combined_image_sampler_index_nvx(self, image_view_index, sampler_index) }
	}
}

#[cfg(feature = "platform-win32")]
/// Call `vkGetPhysicalDeviceSurfacePresentModes2EXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceSurfacePresentModes2EXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceSurfacePresentModes2EXT")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSurfacePresentModes2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSurfacePresentModes2EXT.html)"]
pub unsafe fn get_physical_device_surface_present_modes2_ext(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_surface_info: *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
	p_present_mode_count: *mut u32,
	p_present_modes: *mut vk::PresentModeKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_surface_present_modes2_ext
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceSurfacePresentModes2EXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			physical_device,
			p_surface_info,
			p_present_mode_count,
			p_present_modes,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-win32")]
impl Instance {
	/// Call `vkGetPhysicalDeviceSurfacePresentModes2EXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceSurfacePresentModes2EXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceSurfacePresentModes2EXT")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSurfacePresentModes2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSurfacePresentModes2EXT.html)"]
	#[inline]
	pub unsafe fn get_physical_device_surface_present_modes2_ext(
		&self,
		physical_device: vk::PhysicalDevice,
		p_surface_info: *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
		p_present_mode_count: *mut u32,
		p_present_modes: *mut vk::PresentModeKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_surface_present_modes2_ext(
				self,
				physical_device,
				p_surface_info,
				p_present_mode_count,
				p_present_modes,
			)
		}
	}
}

#[cfg(feature = "platform-win32")]
/// Call `vkGetDeviceGroupSurfacePresentModes2EXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceGroupSurfacePresentModes2EXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeviceGroupSurfacePresentModes2EXT")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceGroupSurfacePresentModes2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceGroupSurfacePresentModes2EXT.html)"]
pub unsafe fn get_device_group_surface_present_modes2_ext(
	device: &Device,
	p_surface_info: *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
	p_modes: *mut vk::DeviceGroupPresentModeFlagsKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_device_group_surface_present_modes2_ext
		.ok_or(CallError::MissingCommand(
			"vkGetDeviceGroupSurfacePresentModes2EXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_surface_info, p_modes) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-win32")]
impl Device {
	/// Call `vkGetDeviceGroupSurfacePresentModes2EXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceGroupSurfacePresentModes2EXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeviceGroupSurfacePresentModes2EXT")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceGroupSurfacePresentModes2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceGroupSurfacePresentModes2EXT.html)"]
	#[inline]
	pub unsafe fn get_device_group_surface_present_modes2_ext(
		&self,
		p_surface_info: *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
		p_modes: *mut vk::DeviceGroupPresentModeFlagsKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_device_group_surface_present_modes2_ext(self, p_surface_info, p_modes) }
	}
}

#[cfg(feature = "platform-win32")]
/// Call `vkAcquireFullScreenExclusiveModeEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkAcquireFullScreenExclusiveModeEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkAcquireFullScreenExclusiveModeEXT")]
#[doc = "\n\n[Khronos reference: `vkAcquireFullScreenExclusiveModeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkAcquireFullScreenExclusiveModeEXT.html)"]
pub unsafe fn acquire_full_screen_exclusive_mode_ext(
	device: &Device,
	swapchain: vk::SwapchainKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.acquire_full_screen_exclusive_mode_ext
			.ok_or(CallError::MissingCommand(
				"vkAcquireFullScreenExclusiveModeEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), swapchain) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-win32")]
impl Device {
	/// Call `vkAcquireFullScreenExclusiveModeEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkAcquireFullScreenExclusiveModeEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkAcquireFullScreenExclusiveModeEXT")]
	#[doc = "\n\n[Khronos reference: `vkAcquireFullScreenExclusiveModeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkAcquireFullScreenExclusiveModeEXT.html)"]
	#[inline]
	pub unsafe fn acquire_full_screen_exclusive_mode_ext(
		&self,
		swapchain: vk::SwapchainKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { acquire_full_screen_exclusive_mode_ext(self, swapchain) }
	}
}

#[cfg(feature = "platform-win32")]
/// Call `vkReleaseFullScreenExclusiveModeEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkReleaseFullScreenExclusiveModeEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkReleaseFullScreenExclusiveModeEXT")]
#[doc = "\n\n[Khronos reference: `vkReleaseFullScreenExclusiveModeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkReleaseFullScreenExclusiveModeEXT.html)"]
pub unsafe fn release_full_screen_exclusive_mode_ext(
	device: &Device,
	swapchain: vk::SwapchainKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.release_full_screen_exclusive_mode_ext
			.ok_or(CallError::MissingCommand(
				"vkReleaseFullScreenExclusiveModeEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), swapchain) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-win32")]
impl Device {
	/// Call `vkReleaseFullScreenExclusiveModeEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkReleaseFullScreenExclusiveModeEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkReleaseFullScreenExclusiveModeEXT")]
	#[doc = "\n\n[Khronos reference: `vkReleaseFullScreenExclusiveModeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkReleaseFullScreenExclusiveModeEXT.html)"]
	#[inline]
	pub unsafe fn release_full_screen_exclusive_mode_ext(
		&self,
		swapchain: vk::SwapchainKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { release_full_screen_exclusive_mode_ext(self, swapchain) }
	}
}

/// Call `vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR")]
#[doc = "\n\n[Khronos reference: `vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html)"]
pub unsafe fn enumerate_physical_device_queue_family_performance_query_counters_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	queue_family_index: u32,
	p_counter_count: *mut u32,
	p_counters: *mut vk::PerformanceCounterKHR<'_>,
	p_counter_descriptions: *mut vk::PerformanceCounterDescriptionKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.enumerate_physical_device_queue_family_performance_query_counters_khr
		.ok_or(CallError::MissingCommand(
			"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			physical_device,
			queue_family_index,
			p_counter_count,
			p_counters,
			p_counter_descriptions,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR")]
	#[doc = "\n\n[Khronos reference: `vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html)"]
	#[inline]
	pub unsafe fn enumerate_physical_device_queue_family_performance_query_counters_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		queue_family_index: u32,
		p_counter_count: *mut u32,
		p_counters: *mut vk::PerformanceCounterKHR<'_>,
		p_counter_descriptions: *mut vk::PerformanceCounterDescriptionKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			enumerate_physical_device_queue_family_performance_query_counters_khr(
				self,
				physical_device,
				queue_family_index,
				p_counter_count,
				p_counters,
				p_counter_descriptions,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html)"]
pub unsafe fn get_physical_device_queue_family_performance_query_passes_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_performance_query_create_info: *const vk::QueryPoolPerformanceCreateInfoKHR<'_>,
	p_num_passes: *mut u32,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_queue_family_performance_query_passes_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			physical_device,
			p_performance_query_create_info,
			p_num_passes,
		)
	};
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_queue_family_performance_query_passes_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		p_performance_query_create_info: *const vk::QueryPoolPerformanceCreateInfoKHR<'_>,
		p_num_passes: *mut u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_queue_family_performance_query_passes_khr(
				self,
				physical_device,
				p_performance_query_create_info,
				p_num_passes,
			)
		}
	}
}

/// Call `vkAcquireProfilingLockKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkAcquireProfilingLockKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkAcquireProfilingLockKHR")]
#[doc = "\n\n[Khronos reference: `vkAcquireProfilingLockKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkAcquireProfilingLockKHR.html)"]
pub unsafe fn acquire_profiling_lock_khr(
	device: &Device,
	p_info: *const vk::AcquireProfilingLockInfoKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.acquire_profiling_lock_khr
		.ok_or(CallError::MissingCommand("vkAcquireProfilingLockKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkAcquireProfilingLockKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkAcquireProfilingLockKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkAcquireProfilingLockKHR")]
	#[doc = "\n\n[Khronos reference: `vkAcquireProfilingLockKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkAcquireProfilingLockKHR.html)"]
	#[inline]
	pub unsafe fn acquire_profiling_lock_khr(
		&self,
		p_info: *const vk::AcquireProfilingLockInfoKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { acquire_profiling_lock_khr(self, p_info) }
	}
}

/// Call `vkReleaseProfilingLockKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkReleaseProfilingLockKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkReleaseProfilingLockKHR")]
#[doc = "\n\n[Khronos reference: `vkReleaseProfilingLockKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkReleaseProfilingLockKHR.html)"]
pub unsafe fn release_profiling_lock_khr(device: &Device) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.release_profiling_lock_khr
		.ok_or(CallError::MissingCommand("vkReleaseProfilingLockKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle()) };
	Ok(())
}

impl Device {
	/// Call `vkReleaseProfilingLockKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkReleaseProfilingLockKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkReleaseProfilingLockKHR")]
	#[doc = "\n\n[Khronos reference: `vkReleaseProfilingLockKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkReleaseProfilingLockKHR.html)"]
	#[inline]
	pub unsafe fn release_profiling_lock_khr(&self) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { release_profiling_lock_khr(self) }
	}
}

/// Call `vkGetImageDrmFormatModifierPropertiesEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetImageDrmFormatModifierPropertiesEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetImageDrmFormatModifierPropertiesEXT")]
#[doc = "\n\n[Khronos reference: `vkGetImageDrmFormatModifierPropertiesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageDrmFormatModifierPropertiesEXT.html)"]
pub unsafe fn get_image_drm_format_modifier_properties_ext(
	device: &Device,
	image: vk::Image,
	p_properties: *mut vk::ImageDrmFormatModifierPropertiesEXT<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_image_drm_format_modifier_properties_ext
		.ok_or(CallError::MissingCommand(
			"vkGetImageDrmFormatModifierPropertiesEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), image, p_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetImageDrmFormatModifierPropertiesEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetImageDrmFormatModifierPropertiesEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetImageDrmFormatModifierPropertiesEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetImageDrmFormatModifierPropertiesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageDrmFormatModifierPropertiesEXT.html)"]
	#[inline]
	pub unsafe fn get_image_drm_format_modifier_properties_ext(
		&self,
		image: vk::Image,
		p_properties: *mut vk::ImageDrmFormatModifierPropertiesEXT<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_image_drm_format_modifier_properties_ext(self, image, p_properties) }
	}
}

/// Call `vkGetBufferOpaqueCaptureAddress` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command; the native scalar is never converted to a status.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetBufferOpaqueCaptureAddress` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Returns the native 64-bit value unchanged, including zero. This is not a
/// VkResult status; opaque capture values are tokens, not dereferenceable addresses.
/// This call neither owns memory nor establishes its lifetime or device accessibility.
#[doc(alias = "vkGetBufferOpaqueCaptureAddress")]
#[doc = "\n\n[Khronos reference: `vkGetBufferOpaqueCaptureAddress`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetBufferOpaqueCaptureAddress.html)"]
pub unsafe fn get_buffer_opaque_capture_address(
	device: &Device,
	info: &vk::BufferDeviceAddressInfo<'_>,
) -> Result<u64, CallError> {
	let __vk_function = device
		.fp()
		.get_buffer_opaque_capture_address
		.ok_or(CallError::MissingCommand("vkGetBufferOpaqueCaptureAddress"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), info) };
	Ok(result)
}

impl Device {
	/// Call `vkGetBufferOpaqueCaptureAddress` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command; the native scalar is never converted to a status.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetBufferOpaqueCaptureAddress` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Returns the native 64-bit value unchanged, including zero. This is not a
	/// VkResult status; opaque capture values are tokens, not dereferenceable addresses.
	/// This call neither owns memory nor establishes its lifetime or device accessibility.
	#[doc(alias = "vkGetBufferOpaqueCaptureAddress")]
	#[doc = "\n\n[Khronos reference: `vkGetBufferOpaqueCaptureAddress`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetBufferOpaqueCaptureAddress.html)"]
	#[inline]
	pub unsafe fn get_buffer_opaque_capture_address(
		&self,
		info: &vk::BufferDeviceAddressInfo<'_>,
	) -> Result<u64, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_buffer_opaque_capture_address(self, info) }
	}
}

/// Call `vkGetBufferOpaqueCaptureAddressKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command; the native scalar is never converted to a status.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetBufferOpaqueCaptureAddressKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Returns the native 64-bit value unchanged, including zero. This is not a
/// VkResult status; opaque capture values are tokens, not dereferenceable addresses.
/// This call neither owns memory nor establishes its lifetime or device accessibility.
#[doc(alias = "vkGetBufferOpaqueCaptureAddressKHR")]
#[doc = "\n\n[Khronos reference: `vkGetBufferOpaqueCaptureAddressKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetBufferOpaqueCaptureAddressKHR.html)"]
pub unsafe fn get_buffer_opaque_capture_address_khr(
	device: &Device,
	info: &vk::BufferDeviceAddressInfo<'_>,
) -> Result<u64, CallError> {
	let __vk_function =
		device
			.fp()
			.get_buffer_opaque_capture_address_khr
			.ok_or(CallError::MissingCommand(
				"vkGetBufferOpaqueCaptureAddressKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), info) };
	Ok(result)
}

impl Device {
	/// Call `vkGetBufferOpaqueCaptureAddressKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command; the native scalar is never converted to a status.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetBufferOpaqueCaptureAddressKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Returns the native 64-bit value unchanged, including zero. This is not a
	/// VkResult status; opaque capture values are tokens, not dereferenceable addresses.
	/// This call neither owns memory nor establishes its lifetime or device accessibility.
	#[doc(alias = "vkGetBufferOpaqueCaptureAddressKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetBufferOpaqueCaptureAddressKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetBufferOpaqueCaptureAddressKHR.html)"]
	#[inline]
	pub unsafe fn get_buffer_opaque_capture_address_khr(
		&self,
		info: &vk::BufferDeviceAddressInfo<'_>,
	) -> Result<u64, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_buffer_opaque_capture_address_khr(self, info) }
	}
}

/// Call `vkGetBufferDeviceAddress` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command; the native scalar is never converted to a status.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetBufferDeviceAddress` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Returns the native 64-bit value unchanged, including zero. This is not a
/// VkResult status; opaque capture values are tokens, not dereferenceable addresses.
/// This call neither owns memory nor establishes its lifetime or device accessibility.
#[doc(alias = "vkGetBufferDeviceAddress")]
#[doc = "\n\n[Khronos reference: `vkGetBufferDeviceAddress`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetBufferDeviceAddress.html)"]
pub unsafe fn get_buffer_device_address(
	device: &Device,
	info: &vk::BufferDeviceAddressInfo<'_>,
) -> Result<vk::DeviceAddress, CallError> {
	let __vk_function = device
		.fp()
		.get_buffer_device_address
		.ok_or(CallError::MissingCommand("vkGetBufferDeviceAddress"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), info) };
	Ok(result)
}

impl Device {
	/// Call `vkGetBufferDeviceAddress` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command; the native scalar is never converted to a status.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetBufferDeviceAddress` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Returns the native 64-bit value unchanged, including zero. This is not a
	/// VkResult status; opaque capture values are tokens, not dereferenceable addresses.
	/// This call neither owns memory nor establishes its lifetime or device accessibility.
	#[doc(alias = "vkGetBufferDeviceAddress")]
	#[doc = "\n\n[Khronos reference: `vkGetBufferDeviceAddress`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetBufferDeviceAddress.html)"]
	#[inline]
	pub unsafe fn get_buffer_device_address(
		&self,
		info: &vk::BufferDeviceAddressInfo<'_>,
	) -> Result<vk::DeviceAddress, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_buffer_device_address(self, info) }
	}
}

/// Call `vkGetBufferDeviceAddressKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command; the native scalar is never converted to a status.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetBufferDeviceAddressKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Returns the native 64-bit value unchanged, including zero. This is not a
/// VkResult status; opaque capture values are tokens, not dereferenceable addresses.
/// This call neither owns memory nor establishes its lifetime or device accessibility.
#[doc(alias = "vkGetBufferDeviceAddressKHR")]
#[doc = "\n\n[Khronos reference: `vkGetBufferDeviceAddressKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetBufferDeviceAddressKHR.html)"]
pub unsafe fn get_buffer_device_address_khr(
	device: &Device,
	info: &vk::BufferDeviceAddressInfo<'_>,
) -> Result<vk::DeviceAddress, CallError> {
	let __vk_function = device
		.fp()
		.get_buffer_device_address_khr
		.ok_or(CallError::MissingCommand("vkGetBufferDeviceAddressKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), info) };
	Ok(result)
}

impl Device {
	/// Call `vkGetBufferDeviceAddressKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command; the native scalar is never converted to a status.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetBufferDeviceAddressKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Returns the native 64-bit value unchanged, including zero. This is not a
	/// VkResult status; opaque capture values are tokens, not dereferenceable addresses.
	/// This call neither owns memory nor establishes its lifetime or device accessibility.
	#[doc(alias = "vkGetBufferDeviceAddressKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetBufferDeviceAddressKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetBufferDeviceAddressKHR.html)"]
	#[inline]
	pub unsafe fn get_buffer_device_address_khr(
		&self,
		info: &vk::BufferDeviceAddressInfo<'_>,
	) -> Result<vk::DeviceAddress, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_buffer_device_address_khr(self, info) }
	}
}

/// Call `vkGetBufferDeviceAddressEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command; the native scalar is never converted to a status.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetBufferDeviceAddressEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Returns the native 64-bit value unchanged, including zero. This is not a
/// VkResult status; opaque capture values are tokens, not dereferenceable addresses.
/// This call neither owns memory nor establishes its lifetime or device accessibility.
#[doc(alias = "vkGetBufferDeviceAddressEXT")]
#[doc = "\n\n[Khronos reference: `vkGetBufferDeviceAddressEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetBufferDeviceAddressEXT.html)"]
pub unsafe fn get_buffer_device_address_ext(
	device: &Device,
	info: &vk::BufferDeviceAddressInfo<'_>,
) -> Result<vk::DeviceAddress, CallError> {
	let __vk_function = device
		.fp()
		.get_buffer_device_address_ext
		.ok_or(CallError::MissingCommand("vkGetBufferDeviceAddressEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), info) };
	Ok(result)
}

impl Device {
	/// Call `vkGetBufferDeviceAddressEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command; the native scalar is never converted to a status.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetBufferDeviceAddressEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Returns the native 64-bit value unchanged, including zero. This is not a
	/// VkResult status; opaque capture values are tokens, not dereferenceable addresses.
	/// This call neither owns memory nor establishes its lifetime or device accessibility.
	#[doc(alias = "vkGetBufferDeviceAddressEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetBufferDeviceAddressEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetBufferDeviceAddressEXT.html)"]
	#[inline]
	pub unsafe fn get_buffer_device_address_ext(
		&self,
		info: &vk::BufferDeviceAddressInfo<'_>,
	) -> Result<vk::DeviceAddress, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_buffer_device_address_ext(self, info) }
	}
}

/// Call `vkCreateHeadlessSurfaceEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateHeadlessSurfaceEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateHeadlessSurfaceEXT")]
#[doc = "\n\n[Khronos reference: `vkCreateHeadlessSurfaceEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateHeadlessSurfaceEXT.html)"]
pub unsafe fn create_headless_surface_ext(
	instance: &Instance,
	p_create_info: *const vk::HeadlessSurfaceCreateInfoEXT<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_surface: *mut vk::SurfaceKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.create_headless_surface_ext
		.ok_or(CallError::MissingCommand("vkCreateHeadlessSurfaceEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(instance.handle(), p_create_info, p_allocator, p_surface) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkCreateHeadlessSurfaceEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateHeadlessSurfaceEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateHeadlessSurfaceEXT")]
	#[doc = "\n\n[Khronos reference: `vkCreateHeadlessSurfaceEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateHeadlessSurfaceEXT.html)"]
	#[inline]
	pub unsafe fn create_headless_surface_ext(
		&self,
		p_create_info: *const vk::HeadlessSurfaceCreateInfoEXT<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_surface: *mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_headless_surface_ext(self, p_create_info, p_allocator, p_surface) }
	}
}

/// Call `vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html)"]
pub unsafe fn get_physical_device_supported_framebuffer_mixed_samples_combinations_nv(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_combination_count: *mut u32,
	p_combinations: *mut vk::FramebufferMixedSamplesCombinationNV<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_supported_framebuffer_mixed_samples_combinations_nv
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, p_combination_count, p_combinations) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html)"]
	#[inline]
	pub unsafe fn get_physical_device_supported_framebuffer_mixed_samples_combinations_nv(
		&self,
		physical_device: vk::PhysicalDevice,
		p_combination_count: *mut u32,
		p_combinations: *mut vk::FramebufferMixedSamplesCombinationNV<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_supported_framebuffer_mixed_samples_combinations_nv(
				self,
				physical_device,
				p_combination_count,
				p_combinations,
			)
		}
	}
}

/// Call `vkInitializePerformanceApiINTEL` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkInitializePerformanceApiINTEL` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkInitializePerformanceApiINTEL")]
#[doc = "\n\n[Khronos reference: `vkInitializePerformanceApiINTEL`](https://docs.vulkan.org/refpages/latest/refpages/source/vkInitializePerformanceApiINTEL.html)"]
pub unsafe fn initialize_performance_api_intel(
	device: &Device,
	p_initialize_info: *const vk::InitializePerformanceApiInfoINTEL<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.initialize_performance_api_intel
		.ok_or(CallError::MissingCommand("vkInitializePerformanceApiINTEL"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_initialize_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkInitializePerformanceApiINTEL` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkInitializePerformanceApiINTEL` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkInitializePerformanceApiINTEL")]
	#[doc = "\n\n[Khronos reference: `vkInitializePerformanceApiINTEL`](https://docs.vulkan.org/refpages/latest/refpages/source/vkInitializePerformanceApiINTEL.html)"]
	#[inline]
	pub unsafe fn initialize_performance_api_intel(
		&self,
		p_initialize_info: *const vk::InitializePerformanceApiInfoINTEL<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { initialize_performance_api_intel(self, p_initialize_info) }
	}
}

/// Call `vkUninitializePerformanceApiINTEL` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkUninitializePerformanceApiINTEL` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkUninitializePerformanceApiINTEL")]
#[doc = "\n\n[Khronos reference: `vkUninitializePerformanceApiINTEL`](https://docs.vulkan.org/refpages/latest/refpages/source/vkUninitializePerformanceApiINTEL.html)"]
pub unsafe fn uninitialize_performance_api_intel(device: &Device) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.uninitialize_performance_api_intel
			.ok_or(CallError::MissingCommand(
				"vkUninitializePerformanceApiINTEL",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle()) };
	Ok(())
}

impl Device {
	/// Call `vkUninitializePerformanceApiINTEL` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkUninitializePerformanceApiINTEL` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkUninitializePerformanceApiINTEL")]
	#[doc = "\n\n[Khronos reference: `vkUninitializePerformanceApiINTEL`](https://docs.vulkan.org/refpages/latest/refpages/source/vkUninitializePerformanceApiINTEL.html)"]
	#[inline]
	pub unsafe fn uninitialize_performance_api_intel(&self) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { uninitialize_performance_api_intel(self) }
	}
}

/// Call `vkCmdSetPerformanceMarkerINTEL` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetPerformanceMarkerINTEL` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetPerformanceMarkerINTEL")]
#[doc = "\n\n[Khronos reference: `vkCmdSetPerformanceMarkerINTEL`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetPerformanceMarkerINTEL.html)"]
pub unsafe fn cmd_set_performance_marker_intel(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_marker_info: *const vk::PerformanceMarkerInfoINTEL<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_performance_marker_intel
		.ok_or(CallError::MissingCommand("vkCmdSetPerformanceMarkerINTEL"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(command_buffer, p_marker_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCmdSetPerformanceMarkerINTEL` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetPerformanceMarkerINTEL` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetPerformanceMarkerINTEL")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetPerformanceMarkerINTEL`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetPerformanceMarkerINTEL.html)"]
	#[inline]
	pub unsafe fn cmd_set_performance_marker_intel(
		&self,
		command_buffer: vk::CommandBuffer,
		p_marker_info: *const vk::PerformanceMarkerInfoINTEL<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_performance_marker_intel(self, command_buffer, p_marker_info) }
	}
}

/// Call `vkCmdSetPerformanceStreamMarkerINTEL` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetPerformanceStreamMarkerINTEL` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetPerformanceStreamMarkerINTEL")]
#[doc = "\n\n[Khronos reference: `vkCmdSetPerformanceStreamMarkerINTEL`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetPerformanceStreamMarkerINTEL.html)"]
pub unsafe fn cmd_set_performance_stream_marker_intel(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_marker_info: *const vk::PerformanceStreamMarkerInfoINTEL<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_performance_stream_marker_intel
			.ok_or(CallError::MissingCommand(
				"vkCmdSetPerformanceStreamMarkerINTEL",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(command_buffer, p_marker_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCmdSetPerformanceStreamMarkerINTEL` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetPerformanceStreamMarkerINTEL` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetPerformanceStreamMarkerINTEL")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetPerformanceStreamMarkerINTEL`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetPerformanceStreamMarkerINTEL.html)"]
	#[inline]
	pub unsafe fn cmd_set_performance_stream_marker_intel(
		&self,
		command_buffer: vk::CommandBuffer,
		p_marker_info: *const vk::PerformanceStreamMarkerInfoINTEL<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_performance_stream_marker_intel(self, command_buffer, p_marker_info) }
	}
}

/// Call `vkCmdSetPerformanceOverrideINTEL` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetPerformanceOverrideINTEL` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetPerformanceOverrideINTEL")]
#[doc = "\n\n[Khronos reference: `vkCmdSetPerformanceOverrideINTEL`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetPerformanceOverrideINTEL.html)"]
pub unsafe fn cmd_set_performance_override_intel(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_override_info: *const vk::PerformanceOverrideInfoINTEL<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_performance_override_intel
			.ok_or(CallError::MissingCommand(
				"vkCmdSetPerformanceOverrideINTEL",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(command_buffer, p_override_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCmdSetPerformanceOverrideINTEL` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetPerformanceOverrideINTEL` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetPerformanceOverrideINTEL")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetPerformanceOverrideINTEL`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetPerformanceOverrideINTEL.html)"]
	#[inline]
	pub unsafe fn cmd_set_performance_override_intel(
		&self,
		command_buffer: vk::CommandBuffer,
		p_override_info: *const vk::PerformanceOverrideInfoINTEL<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_performance_override_intel(self, command_buffer, p_override_info) }
	}
}

/// Call `vkAcquirePerformanceConfigurationINTEL` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkAcquirePerformanceConfigurationINTEL` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkAcquirePerformanceConfigurationINTEL")]
#[doc = "\n\n[Khronos reference: `vkAcquirePerformanceConfigurationINTEL`](https://docs.vulkan.org/refpages/latest/refpages/source/vkAcquirePerformanceConfigurationINTEL.html)"]
pub unsafe fn acquire_performance_configuration_intel(
	device: &Device,
	p_acquire_info: *const vk::PerformanceConfigurationAcquireInfoINTEL<'_>,
	p_configuration: *mut vk::PerformanceConfigurationINTEL,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.acquire_performance_configuration_intel
			.ok_or(CallError::MissingCommand(
				"vkAcquirePerformanceConfigurationINTEL",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_acquire_info, p_configuration) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkAcquirePerformanceConfigurationINTEL` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkAcquirePerformanceConfigurationINTEL` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkAcquirePerformanceConfigurationINTEL")]
	#[doc = "\n\n[Khronos reference: `vkAcquirePerformanceConfigurationINTEL`](https://docs.vulkan.org/refpages/latest/refpages/source/vkAcquirePerformanceConfigurationINTEL.html)"]
	#[inline]
	pub unsafe fn acquire_performance_configuration_intel(
		&self,
		p_acquire_info: *const vk::PerformanceConfigurationAcquireInfoINTEL<'_>,
		p_configuration: *mut vk::PerformanceConfigurationINTEL,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { acquire_performance_configuration_intel(self, p_acquire_info, p_configuration) }
	}
}

/// Call `vkReleasePerformanceConfigurationINTEL` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkReleasePerformanceConfigurationINTEL` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkReleasePerformanceConfigurationINTEL")]
#[doc = "\n\n[Khronos reference: `vkReleasePerformanceConfigurationINTEL`](https://docs.vulkan.org/refpages/latest/refpages/source/vkReleasePerformanceConfigurationINTEL.html)"]
pub unsafe fn release_performance_configuration_intel(
	device: &Device,
	configuration: vk::PerformanceConfigurationINTEL,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.release_performance_configuration_intel
			.ok_or(CallError::MissingCommand(
				"vkReleasePerformanceConfigurationINTEL",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), configuration) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkReleasePerformanceConfigurationINTEL` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkReleasePerformanceConfigurationINTEL` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkReleasePerformanceConfigurationINTEL")]
	#[doc = "\n\n[Khronos reference: `vkReleasePerformanceConfigurationINTEL`](https://docs.vulkan.org/refpages/latest/refpages/source/vkReleasePerformanceConfigurationINTEL.html)"]
	#[inline]
	pub unsafe fn release_performance_configuration_intel(
		&self,
		configuration: vk::PerformanceConfigurationINTEL,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { release_performance_configuration_intel(self, configuration) }
	}
}

/// Call `vkQueueSetPerformanceConfigurationINTEL` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkQueueSetPerformanceConfigurationINTEL` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkQueueSetPerformanceConfigurationINTEL")]
#[doc = "\n\n[Khronos reference: `vkQueueSetPerformanceConfigurationINTEL`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueueSetPerformanceConfigurationINTEL.html)"]
pub unsafe fn queue_set_performance_configuration_intel(
	device: &Device,
	queue: vk::Queue,
	configuration: vk::PerformanceConfigurationINTEL,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.queue_set_performance_configuration_intel
		.ok_or(CallError::MissingCommand(
			"vkQueueSetPerformanceConfigurationINTEL",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(queue, configuration) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkQueueSetPerformanceConfigurationINTEL` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkQueueSetPerformanceConfigurationINTEL` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkQueueSetPerformanceConfigurationINTEL")]
	#[doc = "\n\n[Khronos reference: `vkQueueSetPerformanceConfigurationINTEL`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueueSetPerformanceConfigurationINTEL.html)"]
	#[inline]
	pub unsafe fn queue_set_performance_configuration_intel(
		&self,
		queue: vk::Queue,
		configuration: vk::PerformanceConfigurationINTEL,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { queue_set_performance_configuration_intel(self, queue, configuration) }
	}
}

/// Call `vkGetPerformanceParameterINTEL` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPerformanceParameterINTEL` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPerformanceParameterINTEL")]
#[doc = "\n\n[Khronos reference: `vkGetPerformanceParameterINTEL`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPerformanceParameterINTEL.html)"]
pub unsafe fn get_performance_parameter_intel(
	device: &Device,
	parameter: vk::PerformanceParameterTypeINTEL,
	p_value: *mut vk::PerformanceValueINTEL<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_performance_parameter_intel
		.ok_or(CallError::MissingCommand("vkGetPerformanceParameterINTEL"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), parameter, p_value) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetPerformanceParameterINTEL` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPerformanceParameterINTEL` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPerformanceParameterINTEL")]
	#[doc = "\n\n[Khronos reference: `vkGetPerformanceParameterINTEL`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPerformanceParameterINTEL.html)"]
	#[inline]
	pub unsafe fn get_performance_parameter_intel(
		&self,
		parameter: vk::PerformanceParameterTypeINTEL,
		p_value: *mut vk::PerformanceValueINTEL<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_performance_parameter_intel(self, parameter, p_value) }
	}
}

/// Call `vkGetDeviceMemoryOpaqueCaptureAddress` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command; the native scalar is never converted to a status.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceMemoryOpaqueCaptureAddress` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Returns the native 64-bit value unchanged, including zero. This is not a
/// VkResult status; opaque capture values are tokens, not dereferenceable addresses.
/// This call neither owns memory nor establishes its lifetime or device accessibility.
#[doc(alias = "vkGetDeviceMemoryOpaqueCaptureAddress")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceMemoryOpaqueCaptureAddress`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceMemoryOpaqueCaptureAddress.html)"]
pub unsafe fn get_device_memory_opaque_capture_address(
	device: &Device,
	info: &vk::DeviceMemoryOpaqueCaptureAddressInfo<'_>,
) -> Result<u64, CallError> {
	let __vk_function =
		device
			.fp()
			.get_device_memory_opaque_capture_address
			.ok_or(CallError::MissingCommand(
				"vkGetDeviceMemoryOpaqueCaptureAddress",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), info) };
	Ok(result)
}

impl Device {
	/// Call `vkGetDeviceMemoryOpaqueCaptureAddress` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command; the native scalar is never converted to a status.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceMemoryOpaqueCaptureAddress` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Returns the native 64-bit value unchanged, including zero. This is not a
	/// VkResult status; opaque capture values are tokens, not dereferenceable addresses.
	/// This call neither owns memory nor establishes its lifetime or device accessibility.
	#[doc(alias = "vkGetDeviceMemoryOpaqueCaptureAddress")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceMemoryOpaqueCaptureAddress`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceMemoryOpaqueCaptureAddress.html)"]
	#[inline]
	pub unsafe fn get_device_memory_opaque_capture_address(
		&self,
		info: &vk::DeviceMemoryOpaqueCaptureAddressInfo<'_>,
	) -> Result<u64, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_device_memory_opaque_capture_address(self, info) }
	}
}

/// Call `vkGetDeviceMemoryOpaqueCaptureAddressKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command; the native scalar is never converted to a status.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceMemoryOpaqueCaptureAddressKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Returns the native 64-bit value unchanged, including zero. This is not a
/// VkResult status; opaque capture values are tokens, not dereferenceable addresses.
/// This call neither owns memory nor establishes its lifetime or device accessibility.
#[doc(alias = "vkGetDeviceMemoryOpaqueCaptureAddressKHR")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceMemoryOpaqueCaptureAddressKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html)"]
pub unsafe fn get_device_memory_opaque_capture_address_khr(
	device: &Device,
	info: &vk::DeviceMemoryOpaqueCaptureAddressInfo<'_>,
) -> Result<u64, CallError> {
	let __vk_function = device
		.fp()
		.get_device_memory_opaque_capture_address_khr
		.ok_or(CallError::MissingCommand(
			"vkGetDeviceMemoryOpaqueCaptureAddressKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), info) };
	Ok(result)
}

impl Device {
	/// Call `vkGetDeviceMemoryOpaqueCaptureAddressKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command; the native scalar is never converted to a status.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceMemoryOpaqueCaptureAddressKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Returns the native 64-bit value unchanged, including zero. This is not a
	/// VkResult status; opaque capture values are tokens, not dereferenceable addresses.
	/// This call neither owns memory nor establishes its lifetime or device accessibility.
	#[doc(alias = "vkGetDeviceMemoryOpaqueCaptureAddressKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceMemoryOpaqueCaptureAddressKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html)"]
	#[inline]
	pub unsafe fn get_device_memory_opaque_capture_address_khr(
		&self,
		info: &vk::DeviceMemoryOpaqueCaptureAddressInfo<'_>,
	) -> Result<u64, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_device_memory_opaque_capture_address_khr(self, info) }
	}
}

/// Call `vkGetPipelineExecutablePropertiesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPipelineExecutablePropertiesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPipelineExecutablePropertiesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPipelineExecutablePropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPipelineExecutablePropertiesKHR.html)"]
pub unsafe fn get_pipeline_executable_properties_khr(
	device: &Device,
	p_pipeline_info: *const vk::PipelineInfoKHR<'_>,
	p_executable_count: *mut u32,
	p_properties: *mut vk::PipelineExecutablePropertiesKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.get_pipeline_executable_properties_khr
			.ok_or(CallError::MissingCommand(
				"vkGetPipelineExecutablePropertiesKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_pipeline_info,
			p_executable_count,
			p_properties,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetPipelineExecutablePropertiesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPipelineExecutablePropertiesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPipelineExecutablePropertiesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPipelineExecutablePropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPipelineExecutablePropertiesKHR.html)"]
	#[inline]
	pub unsafe fn get_pipeline_executable_properties_khr(
		&self,
		p_pipeline_info: *const vk::PipelineInfoKHR<'_>,
		p_executable_count: *mut u32,
		p_properties: *mut vk::PipelineExecutablePropertiesKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_pipeline_executable_properties_khr(
				self,
				p_pipeline_info,
				p_executable_count,
				p_properties,
			)
		}
	}
}

/// Call `vkGetPipelineExecutableStatisticsKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPipelineExecutableStatisticsKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPipelineExecutableStatisticsKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPipelineExecutableStatisticsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPipelineExecutableStatisticsKHR.html)"]
pub unsafe fn get_pipeline_executable_statistics_khr(
	device: &Device,
	p_executable_info: *const vk::PipelineExecutableInfoKHR<'_>,
	p_statistic_count: *mut u32,
	p_statistics: *mut vk::PipelineExecutableStatisticKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.get_pipeline_executable_statistics_khr
			.ok_or(CallError::MissingCommand(
				"vkGetPipelineExecutableStatisticsKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_executable_info,
			p_statistic_count,
			p_statistics,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetPipelineExecutableStatisticsKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPipelineExecutableStatisticsKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPipelineExecutableStatisticsKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPipelineExecutableStatisticsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPipelineExecutableStatisticsKHR.html)"]
	#[inline]
	pub unsafe fn get_pipeline_executable_statistics_khr(
		&self,
		p_executable_info: *const vk::PipelineExecutableInfoKHR<'_>,
		p_statistic_count: *mut u32,
		p_statistics: *mut vk::PipelineExecutableStatisticKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_pipeline_executable_statistics_khr(
				self,
				p_executable_info,
				p_statistic_count,
				p_statistics,
			)
		}
	}
}

/// Call `vkGetPipelineExecutableInternalRepresentationsKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPipelineExecutableInternalRepresentationsKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPipelineExecutableInternalRepresentationsKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPipelineExecutableInternalRepresentationsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPipelineExecutableInternalRepresentationsKHR.html)"]
pub unsafe fn get_pipeline_executable_internal_representations_khr(
	device: &Device,
	p_executable_info: *const vk::PipelineExecutableInfoKHR<'_>,
	p_internal_representation_count: *mut u32,
	p_internal_representations: *mut vk::PipelineExecutableInternalRepresentationKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_pipeline_executable_internal_representations_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPipelineExecutableInternalRepresentationsKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_executable_info,
			p_internal_representation_count,
			p_internal_representations,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetPipelineExecutableInternalRepresentationsKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPipelineExecutableInternalRepresentationsKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPipelineExecutableInternalRepresentationsKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPipelineExecutableInternalRepresentationsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPipelineExecutableInternalRepresentationsKHR.html)"]
	#[inline]
	pub unsafe fn get_pipeline_executable_internal_representations_khr(
		&self,
		p_executable_info: *const vk::PipelineExecutableInfoKHR<'_>,
		p_internal_representation_count: *mut u32,
		p_internal_representations: *mut vk::PipelineExecutableInternalRepresentationKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_pipeline_executable_internal_representations_khr(
				self,
				p_executable_info,
				p_internal_representation_count,
				p_internal_representations,
			)
		}
	}
}

/// Call `vkCmdSetLineStipple` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetLineStipple` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetLineStipple")]
#[doc = "\n\n[Khronos reference: `vkCmdSetLineStipple`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetLineStipple.html)"]
pub unsafe fn cmd_set_line_stipple(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	line_stipple_factor: u32,
	line_stipple_pattern: u16,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_line_stipple
		.ok_or(CallError::MissingCommand("vkCmdSetLineStipple"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, line_stipple_factor, line_stipple_pattern) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetLineStipple` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetLineStipple` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetLineStipple")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetLineStipple`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetLineStipple.html)"]
	#[inline]
	pub unsafe fn cmd_set_line_stipple(
		&self,
		command_buffer: vk::CommandBuffer,
		line_stipple_factor: u32,
		line_stipple_pattern: u16,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_line_stipple(
				self,
				command_buffer,
				line_stipple_factor,
				line_stipple_pattern,
			)
		}
	}
}

/// Call `vkCmdSetLineStippleKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetLineStippleKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetLineStippleKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdSetLineStippleKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetLineStippleKHR.html)"]
pub unsafe fn cmd_set_line_stipple_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	line_stipple_factor: u32,
	line_stipple_pattern: u16,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_line_stipple_khr
		.ok_or(CallError::MissingCommand("vkCmdSetLineStippleKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, line_stipple_factor, line_stipple_pattern) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetLineStippleKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetLineStippleKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetLineStippleKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetLineStippleKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetLineStippleKHR.html)"]
	#[inline]
	pub unsafe fn cmd_set_line_stipple_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		line_stipple_factor: u32,
		line_stipple_pattern: u16,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_line_stipple_khr(
				self,
				command_buffer,
				line_stipple_factor,
				line_stipple_pattern,
			)
		}
	}
}

/// Call `vkCmdSetLineStippleEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetLineStippleEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetLineStippleEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetLineStippleEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetLineStippleEXT.html)"]
pub unsafe fn cmd_set_line_stipple_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	line_stipple_factor: u32,
	line_stipple_pattern: u16,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_line_stipple_ext
		.ok_or(CallError::MissingCommand("vkCmdSetLineStippleEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, line_stipple_factor, line_stipple_pattern) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetLineStippleEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetLineStippleEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetLineStippleEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetLineStippleEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetLineStippleEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_line_stipple_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		line_stipple_factor: u32,
		line_stipple_pattern: u16,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_line_stipple_ext(
				self,
				command_buffer,
				line_stipple_factor,
				line_stipple_pattern,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceToolProperties` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceToolProperties` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceToolProperties")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceToolProperties`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceToolProperties.html)"]
pub unsafe fn get_physical_device_tool_properties(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_tool_count: *mut u32,
	p_tool_properties: *mut vk::PhysicalDeviceToolProperties<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		instance
			.fp()
			.get_physical_device_tool_properties
			.ok_or(CallError::MissingCommand(
				"vkGetPhysicalDeviceToolProperties",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, p_tool_count, p_tool_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceToolProperties` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceToolProperties` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceToolProperties")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceToolProperties`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceToolProperties.html)"]
	#[inline]
	pub unsafe fn get_physical_device_tool_properties(
		&self,
		physical_device: vk::PhysicalDevice,
		p_tool_count: *mut u32,
		p_tool_properties: *mut vk::PhysicalDeviceToolProperties<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_tool_properties(self, physical_device, p_tool_count, p_tool_properties)
		}
	}
}

/// Call `vkGetPhysicalDeviceToolPropertiesEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceToolPropertiesEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceToolPropertiesEXT")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceToolPropertiesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceToolPropertiesEXT.html)"]
pub unsafe fn get_physical_device_tool_properties_ext(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_tool_count: *mut u32,
	p_tool_properties: *mut vk::PhysicalDeviceToolProperties<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_tool_properties_ext
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceToolPropertiesEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, p_tool_count, p_tool_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceToolPropertiesEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceToolPropertiesEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceToolPropertiesEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceToolPropertiesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceToolPropertiesEXT.html)"]
	#[inline]
	pub unsafe fn get_physical_device_tool_properties_ext(
		&self,
		physical_device: vk::PhysicalDevice,
		p_tool_count: *mut u32,
		p_tool_properties: *mut vk::PhysicalDeviceToolProperties<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_tool_properties_ext(
				self,
				physical_device,
				p_tool_count,
				p_tool_properties,
			)
		}
	}
}

/// Call `vkCreateAccelerationStructureKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateAccelerationStructureKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateAccelerationStructureKHR")]
#[doc = "\n\n[Khronos reference: `vkCreateAccelerationStructureKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateAccelerationStructureKHR.html)"]
pub unsafe fn create_acceleration_structure_khr(
	device: &Device,
	p_create_info: *const vk::AccelerationStructureCreateInfoKHR<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_acceleration_structure: *mut vk::AccelerationStructureKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.create_acceleration_structure_khr
			.ok_or(CallError::MissingCommand(
				"vkCreateAccelerationStructureKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_create_info,
			p_allocator,
			p_acceleration_structure,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateAccelerationStructureKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateAccelerationStructureKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateAccelerationStructureKHR")]
	#[doc = "\n\n[Khronos reference: `vkCreateAccelerationStructureKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateAccelerationStructureKHR.html)"]
	#[inline]
	pub unsafe fn create_acceleration_structure_khr(
		&self,
		p_create_info: *const vk::AccelerationStructureCreateInfoKHR<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_acceleration_structure: *mut vk::AccelerationStructureKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			create_acceleration_structure_khr(self, p_create_info, p_allocator, p_acceleration_structure)
		}
	}
}

/// Call `vkCmdBuildAccelerationStructuresKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBuildAccelerationStructuresKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBuildAccelerationStructuresKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdBuildAccelerationStructuresKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBuildAccelerationStructuresKHR.html)"]
pub unsafe fn cmd_build_acceleration_structures_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	info_count: u32,
	p_infos: *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
	pp_build_range_infos: *const *const vk::AccelerationStructureBuildRangeInfoKHR,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_build_acceleration_structures_khr
			.ok_or(CallError::MissingCommand(
				"vkCmdBuildAccelerationStructuresKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, info_count, p_infos, pp_build_range_infos) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBuildAccelerationStructuresKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBuildAccelerationStructuresKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBuildAccelerationStructuresKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdBuildAccelerationStructuresKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBuildAccelerationStructuresKHR.html)"]
	#[inline]
	pub unsafe fn cmd_build_acceleration_structures_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		info_count: u32,
		p_infos: *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
		pp_build_range_infos: *const *const vk::AccelerationStructureBuildRangeInfoKHR,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_build_acceleration_structures_khr(
				self,
				command_buffer,
				info_count,
				p_infos,
				pp_build_range_infos,
			)
		}
	}
}

/// Call `vkCmdBuildAccelerationStructuresIndirectKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBuildAccelerationStructuresIndirectKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBuildAccelerationStructuresIndirectKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdBuildAccelerationStructuresIndirectKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBuildAccelerationStructuresIndirectKHR.html)"]
pub unsafe fn cmd_build_acceleration_structures_indirect_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	info_count: u32,
	p_infos: *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
	p_indirect_device_addresses: *const vk::DeviceAddress,
	p_indirect_strides: *const u32,
	pp_max_primitive_counts: *const *const u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_build_acceleration_structures_indirect_khr
		.ok_or(CallError::MissingCommand(
			"vkCmdBuildAccelerationStructuresIndirectKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			info_count,
			p_infos,
			p_indirect_device_addresses,
			p_indirect_strides,
			pp_max_primitive_counts,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdBuildAccelerationStructuresIndirectKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBuildAccelerationStructuresIndirectKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBuildAccelerationStructuresIndirectKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdBuildAccelerationStructuresIndirectKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBuildAccelerationStructuresIndirectKHR.html)"]
	#[inline]
	pub unsafe fn cmd_build_acceleration_structures_indirect_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		info_count: u32,
		p_infos: *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
		p_indirect_device_addresses: *const vk::DeviceAddress,
		p_indirect_strides: *const u32,
		pp_max_primitive_counts: *const *const u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_build_acceleration_structures_indirect_khr(
				self,
				command_buffer,
				info_count,
				p_infos,
				p_indirect_device_addresses,
				p_indirect_strides,
				pp_max_primitive_counts,
			)
		}
	}
}

/// Call `vkBuildAccelerationStructuresKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkBuildAccelerationStructuresKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkBuildAccelerationStructuresKHR")]
#[doc = "\n\n[Khronos reference: `vkBuildAccelerationStructuresKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBuildAccelerationStructuresKHR.html)"]
pub unsafe fn build_acceleration_structures_khr(
	device: &Device,
	deferred_operation: vk::DeferredOperationKHR,
	info_count: u32,
	p_infos: *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
	pp_build_range_infos: *const *const vk::AccelerationStructureBuildRangeInfoKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.build_acceleration_structures_khr
			.ok_or(CallError::MissingCommand(
				"vkBuildAccelerationStructuresKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			deferred_operation,
			info_count,
			p_infos,
			pp_build_range_infos,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkBuildAccelerationStructuresKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkBuildAccelerationStructuresKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkBuildAccelerationStructuresKHR")]
	#[doc = "\n\n[Khronos reference: `vkBuildAccelerationStructuresKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBuildAccelerationStructuresKHR.html)"]
	#[inline]
	pub unsafe fn build_acceleration_structures_khr(
		&self,
		deferred_operation: vk::DeferredOperationKHR,
		info_count: u32,
		p_infos: *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
		pp_build_range_infos: *const *const vk::AccelerationStructureBuildRangeInfoKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			build_acceleration_structures_khr(
				self,
				deferred_operation,
				info_count,
				p_infos,
				pp_build_range_infos,
			)
		}
	}
}

/// Call `vkGetAccelerationStructureDeviceAddressKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetAccelerationStructureDeviceAddressKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetAccelerationStructureDeviceAddressKHR")]
#[doc = "\n\n[Khronos reference: `vkGetAccelerationStructureDeviceAddressKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetAccelerationStructureDeviceAddressKHR.html)"]
pub unsafe fn get_acceleration_structure_device_address_khr(
	device: &Device,
	p_info: *const vk::AccelerationStructureDeviceAddressInfoKHR<'_>,
) -> Result<vk::DeviceAddress, CallError> {
	let __vk_function = device
		.fp()
		.get_acceleration_structure_device_address_khr
		.ok_or(CallError::MissingCommand(
			"vkGetAccelerationStructureDeviceAddressKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_info) };
	Ok(result)
}

impl Device {
	/// Call `vkGetAccelerationStructureDeviceAddressKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetAccelerationStructureDeviceAddressKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetAccelerationStructureDeviceAddressKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetAccelerationStructureDeviceAddressKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetAccelerationStructureDeviceAddressKHR.html)"]
	#[inline]
	pub unsafe fn get_acceleration_structure_device_address_khr(
		&self,
		p_info: *const vk::AccelerationStructureDeviceAddressInfoKHR<'_>,
	) -> Result<vk::DeviceAddress, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_acceleration_structure_device_address_khr(self, p_info) }
	}
}

/// Call `vkCreateDeferredOperationKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateDeferredOperationKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateDeferredOperationKHR")]
#[doc = "\n\n[Khronos reference: `vkCreateDeferredOperationKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDeferredOperationKHR.html)"]
pub unsafe fn create_deferred_operation_khr(
	device: &Device,
	p_allocator: *const vk::AllocationCallbacks,
	p_deferred_operation: *mut vk::DeferredOperationKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_deferred_operation_khr
		.ok_or(CallError::MissingCommand("vkCreateDeferredOperationKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_allocator, p_deferred_operation) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateDeferredOperationKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateDeferredOperationKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateDeferredOperationKHR")]
	#[doc = "\n\n[Khronos reference: `vkCreateDeferredOperationKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDeferredOperationKHR.html)"]
	#[inline]
	pub unsafe fn create_deferred_operation_khr(
		&self,
		p_allocator: *const vk::AllocationCallbacks,
		p_deferred_operation: *mut vk::DeferredOperationKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_deferred_operation_khr(self, p_allocator, p_deferred_operation) }
	}
}

/// Call `vkDestroyDeferredOperationKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyDeferredOperationKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyDeferredOperationKHR")]
#[doc = "\n\n[Khronos reference: `vkDestroyDeferredOperationKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyDeferredOperationKHR.html)"]
pub unsafe fn destroy_deferred_operation_khr(
	device: &Device,
	operation: vk::DeferredOperationKHR,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_deferred_operation_khr
		.ok_or(CallError::MissingCommand("vkDestroyDeferredOperationKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), operation, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyDeferredOperationKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyDeferredOperationKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyDeferredOperationKHR")]
	#[doc = "\n\n[Khronos reference: `vkDestroyDeferredOperationKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyDeferredOperationKHR.html)"]
	#[inline]
	pub unsafe fn destroy_deferred_operation_khr(
		&self,
		operation: vk::DeferredOperationKHR,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_deferred_operation_khr(self, operation, p_allocator) }
	}
}

/// Call `vkGetDeferredOperationMaxConcurrencyKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeferredOperationMaxConcurrencyKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeferredOperationMaxConcurrencyKHR")]
#[doc = "\n\n[Khronos reference: `vkGetDeferredOperationMaxConcurrencyKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeferredOperationMaxConcurrencyKHR.html)"]
pub unsafe fn get_deferred_operation_max_concurrency_khr(
	device: &Device,
	operation: vk::DeferredOperationKHR,
) -> Result<u32, CallError> {
	let __vk_function = device
		.fp()
		.get_deferred_operation_max_concurrency_khr
		.ok_or(CallError::MissingCommand(
			"vkGetDeferredOperationMaxConcurrencyKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), operation) };
	Ok(result)
}

impl Device {
	/// Call `vkGetDeferredOperationMaxConcurrencyKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeferredOperationMaxConcurrencyKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeferredOperationMaxConcurrencyKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetDeferredOperationMaxConcurrencyKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeferredOperationMaxConcurrencyKHR.html)"]
	#[inline]
	pub unsafe fn get_deferred_operation_max_concurrency_khr(
		&self,
		operation: vk::DeferredOperationKHR,
	) -> Result<u32, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_deferred_operation_max_concurrency_khr(self, operation) }
	}
}

/// Call `vkGetDeferredOperationResultKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeferredOperationResultKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeferredOperationResultKHR")]
#[doc = "\n\n[Khronos reference: `vkGetDeferredOperationResultKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeferredOperationResultKHR.html)"]
pub unsafe fn get_deferred_operation_result_khr(
	device: &Device,
	operation: vk::DeferredOperationKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_deferred_operation_result_khr
		.ok_or(CallError::MissingCommand("vkGetDeferredOperationResultKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), operation) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetDeferredOperationResultKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeferredOperationResultKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeferredOperationResultKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetDeferredOperationResultKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeferredOperationResultKHR.html)"]
	#[inline]
	pub unsafe fn get_deferred_operation_result_khr(
		&self,
		operation: vk::DeferredOperationKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_deferred_operation_result_khr(self, operation) }
	}
}

/// Call `vkDeferredOperationJoinKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDeferredOperationJoinKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDeferredOperationJoinKHR")]
#[doc = "\n\n[Khronos reference: `vkDeferredOperationJoinKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDeferredOperationJoinKHR.html)"]
pub unsafe fn deferred_operation_join_khr(
	device: &Device,
	operation: vk::DeferredOperationKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.deferred_operation_join_khr
		.ok_or(CallError::MissingCommand("vkDeferredOperationJoinKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), operation) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkDeferredOperationJoinKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDeferredOperationJoinKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDeferredOperationJoinKHR")]
	#[doc = "\n\n[Khronos reference: `vkDeferredOperationJoinKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDeferredOperationJoinKHR.html)"]
	#[inline]
	pub unsafe fn deferred_operation_join_khr(
		&self,
		operation: vk::DeferredOperationKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { deferred_operation_join_khr(self, operation) }
	}
}

/// Call `vkGetPipelineIndirectMemoryRequirementsNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPipelineIndirectMemoryRequirementsNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPipelineIndirectMemoryRequirementsNV")]
#[doc = "\n\n[Khronos reference: `vkGetPipelineIndirectMemoryRequirementsNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPipelineIndirectMemoryRequirementsNV.html)"]
pub unsafe fn get_pipeline_indirect_memory_requirements_nv(
	device: &Device,
	p_create_info: *const vk::ComputePipelineCreateInfo<'_>,
	p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_pipeline_indirect_memory_requirements_nv
		.ok_or(CallError::MissingCommand(
			"vkGetPipelineIndirectMemoryRequirementsNV",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_create_info, p_memory_requirements) };
	Ok(())
}

impl Device {
	/// Call `vkGetPipelineIndirectMemoryRequirementsNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPipelineIndirectMemoryRequirementsNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPipelineIndirectMemoryRequirementsNV")]
	#[doc = "\n\n[Khronos reference: `vkGetPipelineIndirectMemoryRequirementsNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPipelineIndirectMemoryRequirementsNV.html)"]
	#[inline]
	pub unsafe fn get_pipeline_indirect_memory_requirements_nv(
		&self,
		p_create_info: *const vk::ComputePipelineCreateInfo<'_>,
		p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_pipeline_indirect_memory_requirements_nv(self, p_create_info, p_memory_requirements)
		}
	}
}

/// Call `vkGetPipelineIndirectDeviceAddressNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPipelineIndirectDeviceAddressNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPipelineIndirectDeviceAddressNV")]
#[doc = "\n\n[Khronos reference: `vkGetPipelineIndirectDeviceAddressNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPipelineIndirectDeviceAddressNV.html)"]
pub unsafe fn get_pipeline_indirect_device_address_nv(
	device: &Device,
	p_info: *const vk::PipelineIndirectDeviceAddressInfoNV<'_>,
) -> Result<vk::DeviceAddress, CallError> {
	let __vk_function =
		device
			.fp()
			.get_pipeline_indirect_device_address_nv
			.ok_or(CallError::MissingCommand(
				"vkGetPipelineIndirectDeviceAddressNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_info) };
	Ok(result)
}

impl Device {
	/// Call `vkGetPipelineIndirectDeviceAddressNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPipelineIndirectDeviceAddressNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPipelineIndirectDeviceAddressNV")]
	#[doc = "\n\n[Khronos reference: `vkGetPipelineIndirectDeviceAddressNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPipelineIndirectDeviceAddressNV.html)"]
	#[inline]
	pub unsafe fn get_pipeline_indirect_device_address_nv(
		&self,
		p_info: *const vk::PipelineIndirectDeviceAddressInfoNV<'_>,
	) -> Result<vk::DeviceAddress, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_pipeline_indirect_device_address_nv(self, p_info) }
	}
}

/// Call `vkAntiLagUpdateAMD` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkAntiLagUpdateAMD` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkAntiLagUpdateAMD")]
#[doc = "\n\n[Khronos reference: `vkAntiLagUpdateAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkAntiLagUpdateAMD.html)"]
pub unsafe fn anti_lag_update_amd(
	device: &Device,
	p_data: *const vk::AntiLagDataAMD<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.anti_lag_update_amd
		.ok_or(CallError::MissingCommand("vkAntiLagUpdateAMD"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_data) };
	Ok(())
}

impl Device {
	/// Call `vkAntiLagUpdateAMD` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkAntiLagUpdateAMD` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkAntiLagUpdateAMD")]
	#[doc = "\n\n[Khronos reference: `vkAntiLagUpdateAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkAntiLagUpdateAMD.html)"]
	#[inline]
	pub unsafe fn anti_lag_update_amd(
		&self,
		p_data: *const vk::AntiLagDataAMD<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { anti_lag_update_amd(self, p_data) }
	}
}

/// Call `vkCmdSetCullMode` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetCullMode` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetCullMode")]
#[doc = "\n\n[Khronos reference: `vkCmdSetCullMode`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetCullMode.html)"]
pub unsafe fn cmd_set_cull_mode(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	cull_mode: vk::CullModeFlags,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_cull_mode
		.ok_or(CallError::MissingCommand("vkCmdSetCullMode"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, cull_mode) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetCullMode` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetCullMode` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetCullMode")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetCullMode`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetCullMode.html)"]
	#[inline]
	pub unsafe fn cmd_set_cull_mode(
		&self,
		command_buffer: vk::CommandBuffer,
		cull_mode: vk::CullModeFlags,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_cull_mode(self, command_buffer, cull_mode) }
	}
}

/// Call `vkCmdSetCullModeEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetCullModeEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetCullModeEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetCullModeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetCullModeEXT.html)"]
pub unsafe fn cmd_set_cull_mode_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	cull_mode: vk::CullModeFlags,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_cull_mode_ext
		.ok_or(CallError::MissingCommand("vkCmdSetCullModeEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, cull_mode) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetCullModeEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetCullModeEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetCullModeEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetCullModeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetCullModeEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_cull_mode_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		cull_mode: vk::CullModeFlags,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_cull_mode_ext(self, command_buffer, cull_mode) }
	}
}

/// Call `vkCmdSetFrontFace` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetFrontFace` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetFrontFace")]
#[doc = "\n\n[Khronos reference: `vkCmdSetFrontFace`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetFrontFace.html)"]
pub unsafe fn cmd_set_front_face(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	front_face: vk::FrontFace,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_front_face
		.ok_or(CallError::MissingCommand("vkCmdSetFrontFace"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, front_face) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetFrontFace` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetFrontFace` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetFrontFace")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetFrontFace`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetFrontFace.html)"]
	#[inline]
	pub unsafe fn cmd_set_front_face(
		&self,
		command_buffer: vk::CommandBuffer,
		front_face: vk::FrontFace,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_front_face(self, command_buffer, front_face) }
	}
}

/// Call `vkCmdSetFrontFaceEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetFrontFaceEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetFrontFaceEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetFrontFaceEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetFrontFaceEXT.html)"]
pub unsafe fn cmd_set_front_face_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	front_face: vk::FrontFace,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_front_face_ext
		.ok_or(CallError::MissingCommand("vkCmdSetFrontFaceEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, front_face) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetFrontFaceEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetFrontFaceEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetFrontFaceEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetFrontFaceEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetFrontFaceEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_front_face_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		front_face: vk::FrontFace,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_front_face_ext(self, command_buffer, front_face) }
	}
}

/// Call `vkCmdSetPrimitiveTopology` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetPrimitiveTopology` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetPrimitiveTopology")]
#[doc = "\n\n[Khronos reference: `vkCmdSetPrimitiveTopology`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetPrimitiveTopology.html)"]
pub unsafe fn cmd_set_primitive_topology(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	primitive_topology: vk::PrimitiveTopology,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_primitive_topology
		.ok_or(CallError::MissingCommand("vkCmdSetPrimitiveTopology"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, primitive_topology) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetPrimitiveTopology` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetPrimitiveTopology` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetPrimitiveTopology")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetPrimitiveTopology`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetPrimitiveTopology.html)"]
	#[inline]
	pub unsafe fn cmd_set_primitive_topology(
		&self,
		command_buffer: vk::CommandBuffer,
		primitive_topology: vk::PrimitiveTopology,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_primitive_topology(self, command_buffer, primitive_topology) }
	}
}

/// Call `vkCmdSetPrimitiveTopologyEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetPrimitiveTopologyEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetPrimitiveTopologyEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetPrimitiveTopologyEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetPrimitiveTopologyEXT.html)"]
pub unsafe fn cmd_set_primitive_topology_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	primitive_topology: vk::PrimitiveTopology,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_primitive_topology_ext
		.ok_or(CallError::MissingCommand("vkCmdSetPrimitiveTopologyEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, primitive_topology) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetPrimitiveTopologyEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetPrimitiveTopologyEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetPrimitiveTopologyEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetPrimitiveTopologyEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetPrimitiveTopologyEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_primitive_topology_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		primitive_topology: vk::PrimitiveTopology,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_primitive_topology_ext(self, command_buffer, primitive_topology) }
	}
}

/// Call `vkCmdSetViewportWithCount` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetViewportWithCount` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetViewportWithCount")]
#[doc = "\n\n[Khronos reference: `vkCmdSetViewportWithCount`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetViewportWithCount.html)"]
pub unsafe fn cmd_set_viewport_with_count(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	viewport_count: u32,
	p_viewports: *const vk::Viewport,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_viewport_with_count
		.ok_or(CallError::MissingCommand("vkCmdSetViewportWithCount"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, viewport_count, p_viewports) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetViewportWithCount` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetViewportWithCount` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetViewportWithCount")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetViewportWithCount`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetViewportWithCount.html)"]
	#[inline]
	pub unsafe fn cmd_set_viewport_with_count(
		&self,
		command_buffer: vk::CommandBuffer,
		viewport_count: u32,
		p_viewports: *const vk::Viewport,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_viewport_with_count(self, command_buffer, viewport_count, p_viewports) }
	}
}

/// Call `vkCmdSetViewportWithCountEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetViewportWithCountEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetViewportWithCountEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetViewportWithCountEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetViewportWithCountEXT.html)"]
pub unsafe fn cmd_set_viewport_with_count_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	viewport_count: u32,
	p_viewports: *const vk::Viewport,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_viewport_with_count_ext
		.ok_or(CallError::MissingCommand("vkCmdSetViewportWithCountEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, viewport_count, p_viewports) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetViewportWithCountEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetViewportWithCountEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetViewportWithCountEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetViewportWithCountEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetViewportWithCountEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_viewport_with_count_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		viewport_count: u32,
		p_viewports: *const vk::Viewport,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_viewport_with_count_ext(self, command_buffer, viewport_count, p_viewports) }
	}
}

/// Call `vkCmdSetScissorWithCount` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetScissorWithCount` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetScissorWithCount")]
#[doc = "\n\n[Khronos reference: `vkCmdSetScissorWithCount`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetScissorWithCount.html)"]
pub unsafe fn cmd_set_scissor_with_count(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	scissor_count: u32,
	p_scissors: *const vk::Rect2D,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_scissor_with_count
		.ok_or(CallError::MissingCommand("vkCmdSetScissorWithCount"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, scissor_count, p_scissors) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetScissorWithCount` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetScissorWithCount` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetScissorWithCount")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetScissorWithCount`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetScissorWithCount.html)"]
	#[inline]
	pub unsafe fn cmd_set_scissor_with_count(
		&self,
		command_buffer: vk::CommandBuffer,
		scissor_count: u32,
		p_scissors: *const vk::Rect2D,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_scissor_with_count(self, command_buffer, scissor_count, p_scissors) }
	}
}

/// Call `vkCmdSetScissorWithCountEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetScissorWithCountEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetScissorWithCountEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetScissorWithCountEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetScissorWithCountEXT.html)"]
pub unsafe fn cmd_set_scissor_with_count_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	scissor_count: u32,
	p_scissors: *const vk::Rect2D,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_scissor_with_count_ext
		.ok_or(CallError::MissingCommand("vkCmdSetScissorWithCountEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, scissor_count, p_scissors) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetScissorWithCountEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetScissorWithCountEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetScissorWithCountEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetScissorWithCountEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetScissorWithCountEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_scissor_with_count_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		scissor_count: u32,
		p_scissors: *const vk::Rect2D,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_scissor_with_count_ext(self, command_buffer, scissor_count, p_scissors) }
	}
}

/// Call `vkCmdBindIndexBuffer2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindIndexBuffer2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBindIndexBuffer2")]
#[doc = "\n\n[Khronos reference: `vkCmdBindIndexBuffer2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindIndexBuffer2.html)"]
pub unsafe fn cmd_bind_index_buffer2(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	buffer: vk::Buffer,
	offset: vk::DeviceSize,
	size: vk::DeviceSize,
	index_type: vk::IndexType,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_index_buffer2
		.ok_or(CallError::MissingCommand("vkCmdBindIndexBuffer2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, buffer, offset, size, index_type) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBindIndexBuffer2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindIndexBuffer2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBindIndexBuffer2")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindIndexBuffer2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindIndexBuffer2.html)"]
	#[inline]
	pub unsafe fn cmd_bind_index_buffer2(
		&self,
		command_buffer: vk::CommandBuffer,
		buffer: vk::Buffer,
		offset: vk::DeviceSize,
		size: vk::DeviceSize,
		index_type: vk::IndexType,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_bind_index_buffer2(self, command_buffer, buffer, offset, size, index_type) }
	}
}

/// Call `vkCmdBindIndexBuffer2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindIndexBuffer2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBindIndexBuffer2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdBindIndexBuffer2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindIndexBuffer2KHR.html)"]
pub unsafe fn cmd_bind_index_buffer2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	buffer: vk::Buffer,
	offset: vk::DeviceSize,
	size: vk::DeviceSize,
	index_type: vk::IndexType,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_index_buffer2_khr
		.ok_or(CallError::MissingCommand("vkCmdBindIndexBuffer2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, buffer, offset, size, index_type) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBindIndexBuffer2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindIndexBuffer2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBindIndexBuffer2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindIndexBuffer2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindIndexBuffer2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_bind_index_buffer2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		buffer: vk::Buffer,
		offset: vk::DeviceSize,
		size: vk::DeviceSize,
		index_type: vk::IndexType,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_bind_index_buffer2_khr(self, command_buffer, buffer, offset, size, index_type) }
	}
}

/// Call `vkCmdBindVertexBuffers2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindVertexBuffers2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBindVertexBuffers2")]
#[doc = "\n\n[Khronos reference: `vkCmdBindVertexBuffers2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindVertexBuffers2.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_bind_vertex_buffers2(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_binding: u32,
	binding_count: u32,
	p_buffers: *const vk::Buffer,
	p_offsets: *const vk::DeviceSize,
	p_sizes: *const vk::DeviceSize,
	p_strides: *const vk::DeviceSize,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_vertex_buffers2
		.ok_or(CallError::MissingCommand("vkCmdBindVertexBuffers2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_binding,
			binding_count,
			p_buffers,
			p_offsets,
			p_sizes,
			p_strides,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdBindVertexBuffers2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindVertexBuffers2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBindVertexBuffers2")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindVertexBuffers2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindVertexBuffers2.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_bind_vertex_buffers2(
		&self,
		command_buffer: vk::CommandBuffer,
		first_binding: u32,
		binding_count: u32,
		p_buffers: *const vk::Buffer,
		p_offsets: *const vk::DeviceSize,
		p_sizes: *const vk::DeviceSize,
		p_strides: *const vk::DeviceSize,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_bind_vertex_buffers2(
				self,
				command_buffer,
				first_binding,
				binding_count,
				p_buffers,
				p_offsets,
				p_sizes,
				p_strides,
			)
		}
	}
}

/// Call `vkCmdBindVertexBuffers2EXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindVertexBuffers2EXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBindVertexBuffers2EXT")]
#[doc = "\n\n[Khronos reference: `vkCmdBindVertexBuffers2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindVertexBuffers2EXT.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_bind_vertex_buffers2_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_binding: u32,
	binding_count: u32,
	p_buffers: *const vk::Buffer,
	p_offsets: *const vk::DeviceSize,
	p_sizes: *const vk::DeviceSize,
	p_strides: *const vk::DeviceSize,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_vertex_buffers2_ext
		.ok_or(CallError::MissingCommand("vkCmdBindVertexBuffers2EXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_binding,
			binding_count,
			p_buffers,
			p_offsets,
			p_sizes,
			p_strides,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdBindVertexBuffers2EXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindVertexBuffers2EXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBindVertexBuffers2EXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindVertexBuffers2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindVertexBuffers2EXT.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_bind_vertex_buffers2_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		first_binding: u32,
		binding_count: u32,
		p_buffers: *const vk::Buffer,
		p_offsets: *const vk::DeviceSize,
		p_sizes: *const vk::DeviceSize,
		p_strides: *const vk::DeviceSize,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_bind_vertex_buffers2_ext(
				self,
				command_buffer,
				first_binding,
				binding_count,
				p_buffers,
				p_offsets,
				p_sizes,
				p_strides,
			)
		}
	}
}

/// Call `vkCmdSetDepthTestEnable` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDepthTestEnable` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDepthTestEnable")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDepthTestEnable`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthTestEnable.html)"]
pub unsafe fn cmd_set_depth_test_enable(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	depth_test_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_depth_test_enable
		.ok_or(CallError::MissingCommand("vkCmdSetDepthTestEnable"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, depth_test_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDepthTestEnable` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDepthTestEnable` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDepthTestEnable")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDepthTestEnable`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthTestEnable.html)"]
	#[inline]
	pub unsafe fn cmd_set_depth_test_enable(
		&self,
		command_buffer: vk::CommandBuffer,
		depth_test_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_depth_test_enable(self, command_buffer, depth_test_enable) }
	}
}

/// Call `vkCmdSetDepthTestEnableEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDepthTestEnableEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDepthTestEnableEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDepthTestEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthTestEnableEXT.html)"]
pub unsafe fn cmd_set_depth_test_enable_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	depth_test_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_depth_test_enable_ext
		.ok_or(CallError::MissingCommand("vkCmdSetDepthTestEnableEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, depth_test_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDepthTestEnableEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDepthTestEnableEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDepthTestEnableEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDepthTestEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthTestEnableEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_depth_test_enable_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		depth_test_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_depth_test_enable_ext(self, command_buffer, depth_test_enable) }
	}
}

/// Call `vkCmdSetDepthWriteEnable` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDepthWriteEnable` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDepthWriteEnable")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDepthWriteEnable`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthWriteEnable.html)"]
pub unsafe fn cmd_set_depth_write_enable(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	depth_write_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_depth_write_enable
		.ok_or(CallError::MissingCommand("vkCmdSetDepthWriteEnable"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, depth_write_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDepthWriteEnable` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDepthWriteEnable` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDepthWriteEnable")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDepthWriteEnable`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthWriteEnable.html)"]
	#[inline]
	pub unsafe fn cmd_set_depth_write_enable(
		&self,
		command_buffer: vk::CommandBuffer,
		depth_write_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_depth_write_enable(self, command_buffer, depth_write_enable) }
	}
}

/// Call `vkCmdSetDepthWriteEnableEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDepthWriteEnableEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDepthWriteEnableEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDepthWriteEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthWriteEnableEXT.html)"]
pub unsafe fn cmd_set_depth_write_enable_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	depth_write_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_depth_write_enable_ext
		.ok_or(CallError::MissingCommand("vkCmdSetDepthWriteEnableEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, depth_write_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDepthWriteEnableEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDepthWriteEnableEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDepthWriteEnableEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDepthWriteEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthWriteEnableEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_depth_write_enable_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		depth_write_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_depth_write_enable_ext(self, command_buffer, depth_write_enable) }
	}
}

/// Call `vkCmdSetDepthCompareOp` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDepthCompareOp` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDepthCompareOp")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDepthCompareOp`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthCompareOp.html)"]
pub unsafe fn cmd_set_depth_compare_op(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	depth_compare_op: vk::CompareOp,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_depth_compare_op
		.ok_or(CallError::MissingCommand("vkCmdSetDepthCompareOp"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, depth_compare_op) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDepthCompareOp` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDepthCompareOp` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDepthCompareOp")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDepthCompareOp`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthCompareOp.html)"]
	#[inline]
	pub unsafe fn cmd_set_depth_compare_op(
		&self,
		command_buffer: vk::CommandBuffer,
		depth_compare_op: vk::CompareOp,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_depth_compare_op(self, command_buffer, depth_compare_op) }
	}
}

/// Call `vkCmdSetDepthCompareOpEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDepthCompareOpEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDepthCompareOpEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDepthCompareOpEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthCompareOpEXT.html)"]
pub unsafe fn cmd_set_depth_compare_op_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	depth_compare_op: vk::CompareOp,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_depth_compare_op_ext
		.ok_or(CallError::MissingCommand("vkCmdSetDepthCompareOpEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, depth_compare_op) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDepthCompareOpEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDepthCompareOpEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDepthCompareOpEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDepthCompareOpEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthCompareOpEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_depth_compare_op_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		depth_compare_op: vk::CompareOp,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_depth_compare_op_ext(self, command_buffer, depth_compare_op) }
	}
}

/// Call `vkCmdSetDepthBoundsTestEnable` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDepthBoundsTestEnable` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDepthBoundsTestEnable")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDepthBoundsTestEnable`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthBoundsTestEnable.html)"]
pub unsafe fn cmd_set_depth_bounds_test_enable(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	depth_bounds_test_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_depth_bounds_test_enable
		.ok_or(CallError::MissingCommand("vkCmdSetDepthBoundsTestEnable"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, depth_bounds_test_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDepthBoundsTestEnable` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDepthBoundsTestEnable` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDepthBoundsTestEnable")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDepthBoundsTestEnable`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthBoundsTestEnable.html)"]
	#[inline]
	pub unsafe fn cmd_set_depth_bounds_test_enable(
		&self,
		command_buffer: vk::CommandBuffer,
		depth_bounds_test_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_depth_bounds_test_enable(self, command_buffer, depth_bounds_test_enable) }
	}
}

/// Call `vkCmdSetDepthBoundsTestEnableEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDepthBoundsTestEnableEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDepthBoundsTestEnableEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDepthBoundsTestEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthBoundsTestEnableEXT.html)"]
pub unsafe fn cmd_set_depth_bounds_test_enable_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	depth_bounds_test_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_depth_bounds_test_enable_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdSetDepthBoundsTestEnableEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, depth_bounds_test_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDepthBoundsTestEnableEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDepthBoundsTestEnableEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDepthBoundsTestEnableEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDepthBoundsTestEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthBoundsTestEnableEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_depth_bounds_test_enable_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		depth_bounds_test_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_depth_bounds_test_enable_ext(self, command_buffer, depth_bounds_test_enable) }
	}
}

/// Call `vkCmdSetStencilTestEnable` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetStencilTestEnable` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetStencilTestEnable")]
#[doc = "\n\n[Khronos reference: `vkCmdSetStencilTestEnable`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetStencilTestEnable.html)"]
pub unsafe fn cmd_set_stencil_test_enable(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	stencil_test_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_stencil_test_enable
		.ok_or(CallError::MissingCommand("vkCmdSetStencilTestEnable"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, stencil_test_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetStencilTestEnable` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetStencilTestEnable` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetStencilTestEnable")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetStencilTestEnable`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetStencilTestEnable.html)"]
	#[inline]
	pub unsafe fn cmd_set_stencil_test_enable(
		&self,
		command_buffer: vk::CommandBuffer,
		stencil_test_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_stencil_test_enable(self, command_buffer, stencil_test_enable) }
	}
}

/// Call `vkCmdSetStencilTestEnableEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetStencilTestEnableEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetStencilTestEnableEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetStencilTestEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetStencilTestEnableEXT.html)"]
pub unsafe fn cmd_set_stencil_test_enable_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	stencil_test_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_stencil_test_enable_ext
		.ok_or(CallError::MissingCommand("vkCmdSetStencilTestEnableEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, stencil_test_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetStencilTestEnableEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetStencilTestEnableEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetStencilTestEnableEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetStencilTestEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetStencilTestEnableEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_stencil_test_enable_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		stencil_test_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_stencil_test_enable_ext(self, command_buffer, stencil_test_enable) }
	}
}

/// Call `vkCmdSetStencilOp` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetStencilOp` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetStencilOp")]
#[doc = "\n\n[Khronos reference: `vkCmdSetStencilOp`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetStencilOp.html)"]
pub unsafe fn cmd_set_stencil_op(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	face_mask: vk::StencilFaceFlags,
	fail_op: vk::StencilOp,
	pass_op: vk::StencilOp,
	depth_fail_op: vk::StencilOp,
	compare_op: vk::CompareOp,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_stencil_op
		.ok_or(CallError::MissingCommand("vkCmdSetStencilOp"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			face_mask,
			fail_op,
			pass_op,
			depth_fail_op,
			compare_op,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdSetStencilOp` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetStencilOp` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetStencilOp")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetStencilOp`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetStencilOp.html)"]
	#[inline]
	pub unsafe fn cmd_set_stencil_op(
		&self,
		command_buffer: vk::CommandBuffer,
		face_mask: vk::StencilFaceFlags,
		fail_op: vk::StencilOp,
		pass_op: vk::StencilOp,
		depth_fail_op: vk::StencilOp,
		compare_op: vk::CompareOp,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_stencil_op(
				self,
				command_buffer,
				face_mask,
				fail_op,
				pass_op,
				depth_fail_op,
				compare_op,
			)
		}
	}
}

/// Call `vkCmdSetStencilOpEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetStencilOpEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetStencilOpEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetStencilOpEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetStencilOpEXT.html)"]
pub unsafe fn cmd_set_stencil_op_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	face_mask: vk::StencilFaceFlags,
	fail_op: vk::StencilOp,
	pass_op: vk::StencilOp,
	depth_fail_op: vk::StencilOp,
	compare_op: vk::CompareOp,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_stencil_op_ext
		.ok_or(CallError::MissingCommand("vkCmdSetStencilOpEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			face_mask,
			fail_op,
			pass_op,
			depth_fail_op,
			compare_op,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdSetStencilOpEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetStencilOpEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetStencilOpEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetStencilOpEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetStencilOpEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_stencil_op_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		face_mask: vk::StencilFaceFlags,
		fail_op: vk::StencilOp,
		pass_op: vk::StencilOp,
		depth_fail_op: vk::StencilOp,
		compare_op: vk::CompareOp,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_stencil_op_ext(
				self,
				command_buffer,
				face_mask,
				fail_op,
				pass_op,
				depth_fail_op,
				compare_op,
			)
		}
	}
}

/// Call `vkCmdSetPatchControlPointsEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetPatchControlPointsEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetPatchControlPointsEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetPatchControlPointsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetPatchControlPointsEXT.html)"]
pub unsafe fn cmd_set_patch_control_points_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	patch_control_points: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_patch_control_points_ext
		.ok_or(CallError::MissingCommand("vkCmdSetPatchControlPointsEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, patch_control_points) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetPatchControlPointsEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetPatchControlPointsEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetPatchControlPointsEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetPatchControlPointsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetPatchControlPointsEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_patch_control_points_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		patch_control_points: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_patch_control_points_ext(self, command_buffer, patch_control_points) }
	}
}

/// Call `vkCmdSetRasterizerDiscardEnable` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetRasterizerDiscardEnable` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetRasterizerDiscardEnable")]
#[doc = "\n\n[Khronos reference: `vkCmdSetRasterizerDiscardEnable`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetRasterizerDiscardEnable.html)"]
pub unsafe fn cmd_set_rasterizer_discard_enable(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	rasterizer_discard_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_rasterizer_discard_enable
		.ok_or(CallError::MissingCommand("vkCmdSetRasterizerDiscardEnable"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, rasterizer_discard_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetRasterizerDiscardEnable` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetRasterizerDiscardEnable` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetRasterizerDiscardEnable")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetRasterizerDiscardEnable`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetRasterizerDiscardEnable.html)"]
	#[inline]
	pub unsafe fn cmd_set_rasterizer_discard_enable(
		&self,
		command_buffer: vk::CommandBuffer,
		rasterizer_discard_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_rasterizer_discard_enable(self, command_buffer, rasterizer_discard_enable) }
	}
}

/// Call `vkCmdSetRasterizerDiscardEnableEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetRasterizerDiscardEnableEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetRasterizerDiscardEnableEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetRasterizerDiscardEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetRasterizerDiscardEnableEXT.html)"]
pub unsafe fn cmd_set_rasterizer_discard_enable_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	rasterizer_discard_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_rasterizer_discard_enable_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdSetRasterizerDiscardEnableEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, rasterizer_discard_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetRasterizerDiscardEnableEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetRasterizerDiscardEnableEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetRasterizerDiscardEnableEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetRasterizerDiscardEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetRasterizerDiscardEnableEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_rasterizer_discard_enable_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		rasterizer_discard_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_rasterizer_discard_enable_ext(self, command_buffer, rasterizer_discard_enable)
		}
	}
}

/// Call `vkCmdSetDepthBiasEnable` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDepthBiasEnable` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDepthBiasEnable")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDepthBiasEnable`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthBiasEnable.html)"]
pub unsafe fn cmd_set_depth_bias_enable(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	depth_bias_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_depth_bias_enable
		.ok_or(CallError::MissingCommand("vkCmdSetDepthBiasEnable"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, depth_bias_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDepthBiasEnable` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDepthBiasEnable` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDepthBiasEnable")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDepthBiasEnable`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthBiasEnable.html)"]
	#[inline]
	pub unsafe fn cmd_set_depth_bias_enable(
		&self,
		command_buffer: vk::CommandBuffer,
		depth_bias_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_depth_bias_enable(self, command_buffer, depth_bias_enable) }
	}
}

/// Call `vkCmdSetDepthBiasEnableEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDepthBiasEnableEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDepthBiasEnableEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDepthBiasEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthBiasEnableEXT.html)"]
pub unsafe fn cmd_set_depth_bias_enable_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	depth_bias_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_depth_bias_enable_ext
		.ok_or(CallError::MissingCommand("vkCmdSetDepthBiasEnableEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, depth_bias_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDepthBiasEnableEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDepthBiasEnableEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDepthBiasEnableEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDepthBiasEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthBiasEnableEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_depth_bias_enable_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		depth_bias_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_depth_bias_enable_ext(self, command_buffer, depth_bias_enable) }
	}
}

/// Call `vkCmdSetLogicOpEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetLogicOpEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetLogicOpEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetLogicOpEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetLogicOpEXT.html)"]
pub unsafe fn cmd_set_logic_op_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	logic_op: vk::LogicOp,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_logic_op_ext
		.ok_or(CallError::MissingCommand("vkCmdSetLogicOpEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, logic_op) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetLogicOpEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetLogicOpEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetLogicOpEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetLogicOpEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetLogicOpEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_logic_op_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		logic_op: vk::LogicOp,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_logic_op_ext(self, command_buffer, logic_op) }
	}
}

/// Call `vkCmdSetPrimitiveRestartEnable` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetPrimitiveRestartEnable` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetPrimitiveRestartEnable")]
#[doc = "\n\n[Khronos reference: `vkCmdSetPrimitiveRestartEnable`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetPrimitiveRestartEnable.html)"]
pub unsafe fn cmd_set_primitive_restart_enable(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	primitive_restart_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_primitive_restart_enable
		.ok_or(CallError::MissingCommand("vkCmdSetPrimitiveRestartEnable"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, primitive_restart_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetPrimitiveRestartEnable` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetPrimitiveRestartEnable` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetPrimitiveRestartEnable")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetPrimitiveRestartEnable`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetPrimitiveRestartEnable.html)"]
	#[inline]
	pub unsafe fn cmd_set_primitive_restart_enable(
		&self,
		command_buffer: vk::CommandBuffer,
		primitive_restart_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_primitive_restart_enable(self, command_buffer, primitive_restart_enable) }
	}
}

/// Call `vkCmdSetPrimitiveRestartEnableEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetPrimitiveRestartEnableEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetPrimitiveRestartEnableEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetPrimitiveRestartEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetPrimitiveRestartEnableEXT.html)"]
pub unsafe fn cmd_set_primitive_restart_enable_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	primitive_restart_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_primitive_restart_enable_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdSetPrimitiveRestartEnableEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, primitive_restart_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetPrimitiveRestartEnableEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetPrimitiveRestartEnableEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetPrimitiveRestartEnableEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetPrimitiveRestartEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetPrimitiveRestartEnableEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_primitive_restart_enable_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		primitive_restart_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_primitive_restart_enable_ext(self, command_buffer, primitive_restart_enable) }
	}
}

/// Call `vkCmdSetTessellationDomainOriginEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetTessellationDomainOriginEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetTessellationDomainOriginEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetTessellationDomainOriginEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetTessellationDomainOriginEXT.html)"]
pub unsafe fn cmd_set_tessellation_domain_origin_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	domain_origin: vk::TessellationDomainOrigin,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_tessellation_domain_origin_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdSetTessellationDomainOriginEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, domain_origin) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetTessellationDomainOriginEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetTessellationDomainOriginEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetTessellationDomainOriginEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetTessellationDomainOriginEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetTessellationDomainOriginEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_tessellation_domain_origin_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		domain_origin: vk::TessellationDomainOrigin,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_tessellation_domain_origin_ext(self, command_buffer, domain_origin) }
	}
}

/// Call `vkCmdSetDepthClampEnableEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDepthClampEnableEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDepthClampEnableEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDepthClampEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthClampEnableEXT.html)"]
pub unsafe fn cmd_set_depth_clamp_enable_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	depth_clamp_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_depth_clamp_enable_ext
		.ok_or(CallError::MissingCommand("vkCmdSetDepthClampEnableEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, depth_clamp_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDepthClampEnableEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDepthClampEnableEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDepthClampEnableEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDepthClampEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthClampEnableEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_depth_clamp_enable_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		depth_clamp_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_depth_clamp_enable_ext(self, command_buffer, depth_clamp_enable) }
	}
}

/// Call `vkCmdSetPolygonModeEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetPolygonModeEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetPolygonModeEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetPolygonModeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetPolygonModeEXT.html)"]
pub unsafe fn cmd_set_polygon_mode_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	polygon_mode: vk::PolygonMode,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_polygon_mode_ext
		.ok_or(CallError::MissingCommand("vkCmdSetPolygonModeEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, polygon_mode) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetPolygonModeEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetPolygonModeEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetPolygonModeEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetPolygonModeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetPolygonModeEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_polygon_mode_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		polygon_mode: vk::PolygonMode,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_polygon_mode_ext(self, command_buffer, polygon_mode) }
	}
}

/// Call `vkCmdSetRasterizationSamplesEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetRasterizationSamplesEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetRasterizationSamplesEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetRasterizationSamplesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetRasterizationSamplesEXT.html)"]
pub unsafe fn cmd_set_rasterization_samples_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	rasterization_samples: vk::SampleCountFlagBits,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_rasterization_samples_ext
		.ok_or(CallError::MissingCommand("vkCmdSetRasterizationSamplesEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, rasterization_samples) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetRasterizationSamplesEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetRasterizationSamplesEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetRasterizationSamplesEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetRasterizationSamplesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetRasterizationSamplesEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_rasterization_samples_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		rasterization_samples: vk::SampleCountFlagBits,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_rasterization_samples_ext(self, command_buffer, rasterization_samples) }
	}
}

/// Call `vkCmdSetSampleMaskEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetSampleMaskEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetSampleMaskEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetSampleMaskEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetSampleMaskEXT.html)"]
pub unsafe fn cmd_set_sample_mask_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	samples: vk::SampleCountFlagBits,
	p_sample_mask: *const vk::SampleMask,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_sample_mask_ext
		.ok_or(CallError::MissingCommand("vkCmdSetSampleMaskEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, samples, p_sample_mask) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetSampleMaskEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetSampleMaskEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetSampleMaskEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetSampleMaskEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetSampleMaskEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_sample_mask_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		samples: vk::SampleCountFlagBits,
		p_sample_mask: *const vk::SampleMask,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_sample_mask_ext(self, command_buffer, samples, p_sample_mask) }
	}
}

/// Call `vkCmdSetAlphaToCoverageEnableEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetAlphaToCoverageEnableEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetAlphaToCoverageEnableEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetAlphaToCoverageEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetAlphaToCoverageEnableEXT.html)"]
pub unsafe fn cmd_set_alpha_to_coverage_enable_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	alpha_to_coverage_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_alpha_to_coverage_enable_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdSetAlphaToCoverageEnableEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, alpha_to_coverage_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetAlphaToCoverageEnableEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetAlphaToCoverageEnableEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetAlphaToCoverageEnableEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetAlphaToCoverageEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetAlphaToCoverageEnableEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_alpha_to_coverage_enable_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		alpha_to_coverage_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_alpha_to_coverage_enable_ext(self, command_buffer, alpha_to_coverage_enable) }
	}
}

/// Call `vkCmdSetAlphaToOneEnableEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetAlphaToOneEnableEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetAlphaToOneEnableEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetAlphaToOneEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetAlphaToOneEnableEXT.html)"]
pub unsafe fn cmd_set_alpha_to_one_enable_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	alpha_to_one_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_alpha_to_one_enable_ext
		.ok_or(CallError::MissingCommand("vkCmdSetAlphaToOneEnableEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, alpha_to_one_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetAlphaToOneEnableEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetAlphaToOneEnableEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetAlphaToOneEnableEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetAlphaToOneEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetAlphaToOneEnableEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_alpha_to_one_enable_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		alpha_to_one_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_alpha_to_one_enable_ext(self, command_buffer, alpha_to_one_enable) }
	}
}

/// Call `vkCmdSetLogicOpEnableEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetLogicOpEnableEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetLogicOpEnableEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetLogicOpEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetLogicOpEnableEXT.html)"]
pub unsafe fn cmd_set_logic_op_enable_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	logic_op_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_logic_op_enable_ext
		.ok_or(CallError::MissingCommand("vkCmdSetLogicOpEnableEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, logic_op_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetLogicOpEnableEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetLogicOpEnableEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetLogicOpEnableEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetLogicOpEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetLogicOpEnableEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_logic_op_enable_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		logic_op_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_logic_op_enable_ext(self, command_buffer, logic_op_enable) }
	}
}

/// Call `vkCmdSetColorBlendEnableEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetColorBlendEnableEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetColorBlendEnableEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetColorBlendEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetColorBlendEnableEXT.html)"]
pub unsafe fn cmd_set_color_blend_enable_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_attachment: u32,
	attachment_count: u32,
	p_color_blend_enables: *const vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_color_blend_enable_ext
		.ok_or(CallError::MissingCommand("vkCmdSetColorBlendEnableEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_attachment,
			attachment_count,
			p_color_blend_enables,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdSetColorBlendEnableEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetColorBlendEnableEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetColorBlendEnableEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetColorBlendEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetColorBlendEnableEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_color_blend_enable_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		first_attachment: u32,
		attachment_count: u32,
		p_color_blend_enables: *const vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_color_blend_enable_ext(
				self,
				command_buffer,
				first_attachment,
				attachment_count,
				p_color_blend_enables,
			)
		}
	}
}

/// Call `vkCmdSetColorBlendEquationEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetColorBlendEquationEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetColorBlendEquationEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetColorBlendEquationEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetColorBlendEquationEXT.html)"]
pub unsafe fn cmd_set_color_blend_equation_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_attachment: u32,
	attachment_count: u32,
	p_color_blend_equations: *const vk::ColorBlendEquationEXT,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_color_blend_equation_ext
		.ok_or(CallError::MissingCommand("vkCmdSetColorBlendEquationEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_attachment,
			attachment_count,
			p_color_blend_equations,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdSetColorBlendEquationEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetColorBlendEquationEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetColorBlendEquationEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetColorBlendEquationEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetColorBlendEquationEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_color_blend_equation_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		first_attachment: u32,
		attachment_count: u32,
		p_color_blend_equations: *const vk::ColorBlendEquationEXT,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_color_blend_equation_ext(
				self,
				command_buffer,
				first_attachment,
				attachment_count,
				p_color_blend_equations,
			)
		}
	}
}

/// Call `vkCmdSetColorWriteMaskEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetColorWriteMaskEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetColorWriteMaskEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetColorWriteMaskEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetColorWriteMaskEXT.html)"]
pub unsafe fn cmd_set_color_write_mask_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_attachment: u32,
	attachment_count: u32,
	p_color_write_masks: *const vk::ColorComponentFlags,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_color_write_mask_ext
		.ok_or(CallError::MissingCommand("vkCmdSetColorWriteMaskEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_attachment,
			attachment_count,
			p_color_write_masks,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdSetColorWriteMaskEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetColorWriteMaskEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetColorWriteMaskEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetColorWriteMaskEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetColorWriteMaskEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_color_write_mask_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		first_attachment: u32,
		attachment_count: u32,
		p_color_write_masks: *const vk::ColorComponentFlags,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_color_write_mask_ext(
				self,
				command_buffer,
				first_attachment,
				attachment_count,
				p_color_write_masks,
			)
		}
	}
}

/// Call `vkCmdSetRasterizationStreamEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetRasterizationStreamEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetRasterizationStreamEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetRasterizationStreamEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetRasterizationStreamEXT.html)"]
pub unsafe fn cmd_set_rasterization_stream_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	rasterization_stream: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_rasterization_stream_ext
		.ok_or(CallError::MissingCommand("vkCmdSetRasterizationStreamEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, rasterization_stream) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetRasterizationStreamEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetRasterizationStreamEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetRasterizationStreamEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetRasterizationStreamEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetRasterizationStreamEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_rasterization_stream_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		rasterization_stream: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_rasterization_stream_ext(self, command_buffer, rasterization_stream) }
	}
}

/// Call `vkCmdSetConservativeRasterizationModeEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetConservativeRasterizationModeEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetConservativeRasterizationModeEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetConservativeRasterizationModeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetConservativeRasterizationModeEXT.html)"]
pub unsafe fn cmd_set_conservative_rasterization_mode_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	conservative_rasterization_mode: vk::ConservativeRasterizationModeEXT,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_conservative_rasterization_mode_ext
		.ok_or(CallError::MissingCommand(
			"vkCmdSetConservativeRasterizationModeEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, conservative_rasterization_mode) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetConservativeRasterizationModeEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetConservativeRasterizationModeEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetConservativeRasterizationModeEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetConservativeRasterizationModeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetConservativeRasterizationModeEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_conservative_rasterization_mode_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		conservative_rasterization_mode: vk::ConservativeRasterizationModeEXT,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_conservative_rasterization_mode_ext(
				self,
				command_buffer,
				conservative_rasterization_mode,
			)
		}
	}
}

/// Call `vkCmdSetExtraPrimitiveOverestimationSizeEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetExtraPrimitiveOverestimationSizeEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetExtraPrimitiveOverestimationSizeEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetExtraPrimitiveOverestimationSizeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetExtraPrimitiveOverestimationSizeEXT.html)"]
pub unsafe fn cmd_set_extra_primitive_overestimation_size_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	extra_primitive_overestimation_size: f32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_extra_primitive_overestimation_size_ext
		.ok_or(CallError::MissingCommand(
			"vkCmdSetExtraPrimitiveOverestimationSizeEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, extra_primitive_overestimation_size) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetExtraPrimitiveOverestimationSizeEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetExtraPrimitiveOverestimationSizeEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetExtraPrimitiveOverestimationSizeEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetExtraPrimitiveOverestimationSizeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetExtraPrimitiveOverestimationSizeEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_extra_primitive_overestimation_size_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		extra_primitive_overestimation_size: f32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_extra_primitive_overestimation_size_ext(
				self,
				command_buffer,
				extra_primitive_overestimation_size,
			)
		}
	}
}

/// Call `vkCmdSetDepthClipEnableEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDepthClipEnableEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDepthClipEnableEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDepthClipEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthClipEnableEXT.html)"]
pub unsafe fn cmd_set_depth_clip_enable_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	depth_clip_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_depth_clip_enable_ext
		.ok_or(CallError::MissingCommand("vkCmdSetDepthClipEnableEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, depth_clip_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDepthClipEnableEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDepthClipEnableEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDepthClipEnableEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDepthClipEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthClipEnableEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_depth_clip_enable_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		depth_clip_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_depth_clip_enable_ext(self, command_buffer, depth_clip_enable) }
	}
}

/// Call `vkCmdSetSampleLocationsEnableEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetSampleLocationsEnableEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetSampleLocationsEnableEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetSampleLocationsEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetSampleLocationsEnableEXT.html)"]
pub unsafe fn cmd_set_sample_locations_enable_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	sample_locations_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_sample_locations_enable_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdSetSampleLocationsEnableEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, sample_locations_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetSampleLocationsEnableEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetSampleLocationsEnableEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetSampleLocationsEnableEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetSampleLocationsEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetSampleLocationsEnableEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_sample_locations_enable_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		sample_locations_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_sample_locations_enable_ext(self, command_buffer, sample_locations_enable) }
	}
}

/// Call `vkCmdSetColorBlendAdvancedEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetColorBlendAdvancedEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetColorBlendAdvancedEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetColorBlendAdvancedEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetColorBlendAdvancedEXT.html)"]
pub unsafe fn cmd_set_color_blend_advanced_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_attachment: u32,
	attachment_count: u32,
	p_color_blend_advanced: *const vk::ColorBlendAdvancedEXT,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_color_blend_advanced_ext
		.ok_or(CallError::MissingCommand("vkCmdSetColorBlendAdvancedEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_attachment,
			attachment_count,
			p_color_blend_advanced,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdSetColorBlendAdvancedEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetColorBlendAdvancedEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetColorBlendAdvancedEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetColorBlendAdvancedEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetColorBlendAdvancedEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_color_blend_advanced_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		first_attachment: u32,
		attachment_count: u32,
		p_color_blend_advanced: *const vk::ColorBlendAdvancedEXT,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_color_blend_advanced_ext(
				self,
				command_buffer,
				first_attachment,
				attachment_count,
				p_color_blend_advanced,
			)
		}
	}
}

/// Call `vkCmdSetProvokingVertexModeEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetProvokingVertexModeEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetProvokingVertexModeEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetProvokingVertexModeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetProvokingVertexModeEXT.html)"]
pub unsafe fn cmd_set_provoking_vertex_mode_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	provoking_vertex_mode: vk::ProvokingVertexModeEXT,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_provoking_vertex_mode_ext
		.ok_or(CallError::MissingCommand("vkCmdSetProvokingVertexModeEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, provoking_vertex_mode) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetProvokingVertexModeEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetProvokingVertexModeEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetProvokingVertexModeEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetProvokingVertexModeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetProvokingVertexModeEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_provoking_vertex_mode_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		provoking_vertex_mode: vk::ProvokingVertexModeEXT,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_provoking_vertex_mode_ext(self, command_buffer, provoking_vertex_mode) }
	}
}

/// Call `vkCmdSetLineRasterizationModeEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetLineRasterizationModeEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetLineRasterizationModeEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetLineRasterizationModeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetLineRasterizationModeEXT.html)"]
pub unsafe fn cmd_set_line_rasterization_mode_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	line_rasterization_mode: vk::LineRasterizationModeEXT,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_line_rasterization_mode_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdSetLineRasterizationModeEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, line_rasterization_mode) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetLineRasterizationModeEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetLineRasterizationModeEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetLineRasterizationModeEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetLineRasterizationModeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetLineRasterizationModeEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_line_rasterization_mode_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		line_rasterization_mode: vk::LineRasterizationModeEXT,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_line_rasterization_mode_ext(self, command_buffer, line_rasterization_mode) }
	}
}

/// Call `vkCmdSetLineStippleEnableEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetLineStippleEnableEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetLineStippleEnableEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetLineStippleEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetLineStippleEnableEXT.html)"]
pub unsafe fn cmd_set_line_stipple_enable_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	stippled_line_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_line_stipple_enable_ext
		.ok_or(CallError::MissingCommand("vkCmdSetLineStippleEnableEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, stippled_line_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetLineStippleEnableEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetLineStippleEnableEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetLineStippleEnableEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetLineStippleEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetLineStippleEnableEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_line_stipple_enable_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		stippled_line_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_line_stipple_enable_ext(self, command_buffer, stippled_line_enable) }
	}
}

/// Call `vkCmdSetDepthClipNegativeOneToOneEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDepthClipNegativeOneToOneEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDepthClipNegativeOneToOneEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDepthClipNegativeOneToOneEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthClipNegativeOneToOneEXT.html)"]
pub unsafe fn cmd_set_depth_clip_negative_one_to_one_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	negative_one_to_one: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_depth_clip_negative_one_to_one_ext
		.ok_or(CallError::MissingCommand(
			"vkCmdSetDepthClipNegativeOneToOneEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, negative_one_to_one) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDepthClipNegativeOneToOneEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDepthClipNegativeOneToOneEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDepthClipNegativeOneToOneEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDepthClipNegativeOneToOneEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthClipNegativeOneToOneEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_depth_clip_negative_one_to_one_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		negative_one_to_one: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_depth_clip_negative_one_to_one_ext(self, command_buffer, negative_one_to_one) }
	}
}

/// Call `vkCmdSetViewportWScalingEnableNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetViewportWScalingEnableNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetViewportWScalingEnableNV")]
#[doc = "\n\n[Khronos reference: `vkCmdSetViewportWScalingEnableNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetViewportWScalingEnableNV.html)"]
pub unsafe fn cmd_set_viewport_w_scaling_enable_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	viewport_w_scaling_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_viewport_w_scaling_enable_nv
			.ok_or(CallError::MissingCommand(
				"vkCmdSetViewportWScalingEnableNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, viewport_w_scaling_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetViewportWScalingEnableNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetViewportWScalingEnableNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetViewportWScalingEnableNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetViewportWScalingEnableNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetViewportWScalingEnableNV.html)"]
	#[inline]
	pub unsafe fn cmd_set_viewport_w_scaling_enable_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		viewport_w_scaling_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_viewport_w_scaling_enable_nv(self, command_buffer, viewport_w_scaling_enable) }
	}
}

/// Call `vkCmdSetViewportSwizzleNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetViewportSwizzleNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetViewportSwizzleNV")]
#[doc = "\n\n[Khronos reference: `vkCmdSetViewportSwizzleNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetViewportSwizzleNV.html)"]
pub unsafe fn cmd_set_viewport_swizzle_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_viewport: u32,
	viewport_count: u32,
	p_viewport_swizzles: *const vk::ViewportSwizzleNV,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_viewport_swizzle_nv
		.ok_or(CallError::MissingCommand("vkCmdSetViewportSwizzleNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_viewport,
			viewport_count,
			p_viewport_swizzles,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdSetViewportSwizzleNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetViewportSwizzleNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetViewportSwizzleNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetViewportSwizzleNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetViewportSwizzleNV.html)"]
	#[inline]
	pub unsafe fn cmd_set_viewport_swizzle_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		first_viewport: u32,
		viewport_count: u32,
		p_viewport_swizzles: *const vk::ViewportSwizzleNV,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_viewport_swizzle_nv(
				self,
				command_buffer,
				first_viewport,
				viewport_count,
				p_viewport_swizzles,
			)
		}
	}
}

/// Call `vkCmdSetCoverageToColorEnableNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetCoverageToColorEnableNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetCoverageToColorEnableNV")]
#[doc = "\n\n[Khronos reference: `vkCmdSetCoverageToColorEnableNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetCoverageToColorEnableNV.html)"]
pub unsafe fn cmd_set_coverage_to_color_enable_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	coverage_to_color_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_coverage_to_color_enable_nv
		.ok_or(CallError::MissingCommand("vkCmdSetCoverageToColorEnableNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, coverage_to_color_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetCoverageToColorEnableNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetCoverageToColorEnableNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetCoverageToColorEnableNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetCoverageToColorEnableNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetCoverageToColorEnableNV.html)"]
	#[inline]
	pub unsafe fn cmd_set_coverage_to_color_enable_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		coverage_to_color_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_coverage_to_color_enable_nv(self, command_buffer, coverage_to_color_enable) }
	}
}

/// Call `vkCmdSetCoverageToColorLocationNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetCoverageToColorLocationNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetCoverageToColorLocationNV")]
#[doc = "\n\n[Khronos reference: `vkCmdSetCoverageToColorLocationNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetCoverageToColorLocationNV.html)"]
pub unsafe fn cmd_set_coverage_to_color_location_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	coverage_to_color_location: u32,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_coverage_to_color_location_nv
			.ok_or(CallError::MissingCommand(
				"vkCmdSetCoverageToColorLocationNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, coverage_to_color_location) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetCoverageToColorLocationNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetCoverageToColorLocationNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetCoverageToColorLocationNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetCoverageToColorLocationNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetCoverageToColorLocationNV.html)"]
	#[inline]
	pub unsafe fn cmd_set_coverage_to_color_location_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		coverage_to_color_location: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_coverage_to_color_location_nv(self, command_buffer, coverage_to_color_location)
		}
	}
}

/// Call `vkCmdSetCoverageModulationModeNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetCoverageModulationModeNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetCoverageModulationModeNV")]
#[doc = "\n\n[Khronos reference: `vkCmdSetCoverageModulationModeNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetCoverageModulationModeNV.html)"]
pub unsafe fn cmd_set_coverage_modulation_mode_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	coverage_modulation_mode: vk::CoverageModulationModeNV,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_coverage_modulation_mode_nv
			.ok_or(CallError::MissingCommand(
				"vkCmdSetCoverageModulationModeNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, coverage_modulation_mode) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetCoverageModulationModeNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetCoverageModulationModeNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetCoverageModulationModeNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetCoverageModulationModeNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetCoverageModulationModeNV.html)"]
	#[inline]
	pub unsafe fn cmd_set_coverage_modulation_mode_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		coverage_modulation_mode: vk::CoverageModulationModeNV,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_coverage_modulation_mode_nv(self, command_buffer, coverage_modulation_mode) }
	}
}

/// Call `vkCmdSetCoverageModulationTableEnableNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetCoverageModulationTableEnableNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetCoverageModulationTableEnableNV")]
#[doc = "\n\n[Khronos reference: `vkCmdSetCoverageModulationTableEnableNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetCoverageModulationTableEnableNV.html)"]
pub unsafe fn cmd_set_coverage_modulation_table_enable_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	coverage_modulation_table_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_coverage_modulation_table_enable_nv
		.ok_or(CallError::MissingCommand(
			"vkCmdSetCoverageModulationTableEnableNV",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, coverage_modulation_table_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetCoverageModulationTableEnableNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetCoverageModulationTableEnableNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetCoverageModulationTableEnableNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetCoverageModulationTableEnableNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetCoverageModulationTableEnableNV.html)"]
	#[inline]
	pub unsafe fn cmd_set_coverage_modulation_table_enable_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		coverage_modulation_table_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_coverage_modulation_table_enable_nv(
				self,
				command_buffer,
				coverage_modulation_table_enable,
			)
		}
	}
}

/// Call `vkCmdSetCoverageModulationTableNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetCoverageModulationTableNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetCoverageModulationTableNV")]
#[doc = "\n\n[Khronos reference: `vkCmdSetCoverageModulationTableNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetCoverageModulationTableNV.html)"]
pub unsafe fn cmd_set_coverage_modulation_table_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	coverage_modulation_table_count: u32,
	p_coverage_modulation_table: *const f32,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_coverage_modulation_table_nv
			.ok_or(CallError::MissingCommand(
				"vkCmdSetCoverageModulationTableNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			coverage_modulation_table_count,
			p_coverage_modulation_table,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdSetCoverageModulationTableNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetCoverageModulationTableNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetCoverageModulationTableNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetCoverageModulationTableNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetCoverageModulationTableNV.html)"]
	#[inline]
	pub unsafe fn cmd_set_coverage_modulation_table_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		coverage_modulation_table_count: u32,
		p_coverage_modulation_table: *const f32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_coverage_modulation_table_nv(
				self,
				command_buffer,
				coverage_modulation_table_count,
				p_coverage_modulation_table,
			)
		}
	}
}

/// Call `vkCmdSetShadingRateImageEnableNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetShadingRateImageEnableNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetShadingRateImageEnableNV")]
#[doc = "\n\n[Khronos reference: `vkCmdSetShadingRateImageEnableNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetShadingRateImageEnableNV.html)"]
pub unsafe fn cmd_set_shading_rate_image_enable_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	shading_rate_image_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_shading_rate_image_enable_nv
			.ok_or(CallError::MissingCommand(
				"vkCmdSetShadingRateImageEnableNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, shading_rate_image_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetShadingRateImageEnableNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetShadingRateImageEnableNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetShadingRateImageEnableNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetShadingRateImageEnableNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetShadingRateImageEnableNV.html)"]
	#[inline]
	pub unsafe fn cmd_set_shading_rate_image_enable_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		shading_rate_image_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_shading_rate_image_enable_nv(self, command_buffer, shading_rate_image_enable) }
	}
}

/// Call `vkCmdSetCoverageReductionModeNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetCoverageReductionModeNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetCoverageReductionModeNV")]
#[doc = "\n\n[Khronos reference: `vkCmdSetCoverageReductionModeNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetCoverageReductionModeNV.html)"]
pub unsafe fn cmd_set_coverage_reduction_mode_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	coverage_reduction_mode: vk::CoverageReductionModeNV,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_coverage_reduction_mode_nv
		.ok_or(CallError::MissingCommand("vkCmdSetCoverageReductionModeNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, coverage_reduction_mode) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetCoverageReductionModeNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetCoverageReductionModeNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetCoverageReductionModeNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetCoverageReductionModeNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetCoverageReductionModeNV.html)"]
	#[inline]
	pub unsafe fn cmd_set_coverage_reduction_mode_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		coverage_reduction_mode: vk::CoverageReductionModeNV,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_coverage_reduction_mode_nv(self, command_buffer, coverage_reduction_mode) }
	}
}

/// Call `vkCmdSetRepresentativeFragmentTestEnableNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetRepresentativeFragmentTestEnableNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetRepresentativeFragmentTestEnableNV")]
#[doc = "\n\n[Khronos reference: `vkCmdSetRepresentativeFragmentTestEnableNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetRepresentativeFragmentTestEnableNV.html)"]
pub unsafe fn cmd_set_representative_fragment_test_enable_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	representative_fragment_test_enable: vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_representative_fragment_test_enable_nv
		.ok_or(CallError::MissingCommand(
			"vkCmdSetRepresentativeFragmentTestEnableNV",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, representative_fragment_test_enable) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetRepresentativeFragmentTestEnableNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetRepresentativeFragmentTestEnableNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetRepresentativeFragmentTestEnableNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetRepresentativeFragmentTestEnableNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetRepresentativeFragmentTestEnableNV.html)"]
	#[inline]
	pub unsafe fn cmd_set_representative_fragment_test_enable_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		representative_fragment_test_enable: vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_representative_fragment_test_enable_nv(
				self,
				command_buffer,
				representative_fragment_test_enable,
			)
		}
	}
}

/// Call `vkCreatePrivateDataSlot` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreatePrivateDataSlot` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreatePrivateDataSlot")]
#[doc = "\n\n[Khronos reference: `vkCreatePrivateDataSlot`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreatePrivateDataSlot.html)"]
pub unsafe fn create_private_data_slot(
	device: &Device,
	p_create_info: *const vk::PrivateDataSlotCreateInfo<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_private_data_slot: *mut vk::PrivateDataSlot,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_private_data_slot
		.ok_or(CallError::MissingCommand("vkCreatePrivateDataSlot"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_create_info,
			p_allocator,
			p_private_data_slot,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreatePrivateDataSlot` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreatePrivateDataSlot` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreatePrivateDataSlot")]
	#[doc = "\n\n[Khronos reference: `vkCreatePrivateDataSlot`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreatePrivateDataSlot.html)"]
	#[inline]
	pub unsafe fn create_private_data_slot(
		&self,
		p_create_info: *const vk::PrivateDataSlotCreateInfo<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_private_data_slot: *mut vk::PrivateDataSlot,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_private_data_slot(self, p_create_info, p_allocator, p_private_data_slot) }
	}
}

/// Call `vkCreatePrivateDataSlotEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreatePrivateDataSlotEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreatePrivateDataSlotEXT")]
#[doc = "\n\n[Khronos reference: `vkCreatePrivateDataSlotEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreatePrivateDataSlotEXT.html)"]
pub unsafe fn create_private_data_slot_ext(
	device: &Device,
	p_create_info: *const vk::PrivateDataSlotCreateInfo<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_private_data_slot: *mut vk::PrivateDataSlot,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_private_data_slot_ext
		.ok_or(CallError::MissingCommand("vkCreatePrivateDataSlotEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_create_info,
			p_allocator,
			p_private_data_slot,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreatePrivateDataSlotEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreatePrivateDataSlotEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreatePrivateDataSlotEXT")]
	#[doc = "\n\n[Khronos reference: `vkCreatePrivateDataSlotEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreatePrivateDataSlotEXT.html)"]
	#[inline]
	pub unsafe fn create_private_data_slot_ext(
		&self,
		p_create_info: *const vk::PrivateDataSlotCreateInfo<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_private_data_slot: *mut vk::PrivateDataSlot,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_private_data_slot_ext(self, p_create_info, p_allocator, p_private_data_slot) }
	}
}

/// Call `vkDestroyPrivateDataSlot` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyPrivateDataSlot` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyPrivateDataSlot")]
#[doc = "\n\n[Khronos reference: `vkDestroyPrivateDataSlot`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyPrivateDataSlot.html)"]
pub unsafe fn destroy_private_data_slot(
	device: &Device,
	private_data_slot: vk::PrivateDataSlot,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_private_data_slot
		.ok_or(CallError::MissingCommand("vkDestroyPrivateDataSlot"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), private_data_slot, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyPrivateDataSlot` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyPrivateDataSlot` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyPrivateDataSlot")]
	#[doc = "\n\n[Khronos reference: `vkDestroyPrivateDataSlot`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyPrivateDataSlot.html)"]
	#[inline]
	pub unsafe fn destroy_private_data_slot(
		&self,
		private_data_slot: vk::PrivateDataSlot,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_private_data_slot(self, private_data_slot, p_allocator) }
	}
}

/// Call `vkDestroyPrivateDataSlotEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyPrivateDataSlotEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyPrivateDataSlotEXT")]
#[doc = "\n\n[Khronos reference: `vkDestroyPrivateDataSlotEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyPrivateDataSlotEXT.html)"]
pub unsafe fn destroy_private_data_slot_ext(
	device: &Device,
	private_data_slot: vk::PrivateDataSlot,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_private_data_slot_ext
		.ok_or(CallError::MissingCommand("vkDestroyPrivateDataSlotEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), private_data_slot, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyPrivateDataSlotEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyPrivateDataSlotEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyPrivateDataSlotEXT")]
	#[doc = "\n\n[Khronos reference: `vkDestroyPrivateDataSlotEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyPrivateDataSlotEXT.html)"]
	#[inline]
	pub unsafe fn destroy_private_data_slot_ext(
		&self,
		private_data_slot: vk::PrivateDataSlot,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_private_data_slot_ext(self, private_data_slot, p_allocator) }
	}
}

/// Call `vkSetPrivateData` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkSetPrivateData` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkSetPrivateData")]
#[doc = "\n\n[Khronos reference: `vkSetPrivateData`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetPrivateData.html)"]
pub unsafe fn set_private_data(
	device: &Device,
	object_type: vk::ObjectType,
	object_handle: u64,
	private_data_slot: vk::PrivateDataSlot,
	data: u64,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.set_private_data
		.ok_or(CallError::MissingCommand("vkSetPrivateData"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			object_type,
			object_handle,
			private_data_slot,
			data,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkSetPrivateData` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkSetPrivateData` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkSetPrivateData")]
	#[doc = "\n\n[Khronos reference: `vkSetPrivateData`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetPrivateData.html)"]
	#[inline]
	pub unsafe fn set_private_data(
		&self,
		object_type: vk::ObjectType,
		object_handle: u64,
		private_data_slot: vk::PrivateDataSlot,
		data: u64,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { set_private_data(self, object_type, object_handle, private_data_slot, data) }
	}
}

/// Call `vkSetPrivateDataEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkSetPrivateDataEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkSetPrivateDataEXT")]
#[doc = "\n\n[Khronos reference: `vkSetPrivateDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetPrivateDataEXT.html)"]
pub unsafe fn set_private_data_ext(
	device: &Device,
	object_type: vk::ObjectType,
	object_handle: u64,
	private_data_slot: vk::PrivateDataSlot,
	data: u64,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.set_private_data_ext
		.ok_or(CallError::MissingCommand("vkSetPrivateDataEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			object_type,
			object_handle,
			private_data_slot,
			data,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkSetPrivateDataEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkSetPrivateDataEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkSetPrivateDataEXT")]
	#[doc = "\n\n[Khronos reference: `vkSetPrivateDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetPrivateDataEXT.html)"]
	#[inline]
	pub unsafe fn set_private_data_ext(
		&self,
		object_type: vk::ObjectType,
		object_handle: u64,
		private_data_slot: vk::PrivateDataSlot,
		data: u64,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { set_private_data_ext(self, object_type, object_handle, private_data_slot, data) }
	}
}

/// Call `vkGetPrivateData` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPrivateData` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPrivateData")]
#[doc = "\n\n[Khronos reference: `vkGetPrivateData`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPrivateData.html)"]
pub unsafe fn get_private_data(
	device: &Device,
	object_type: vk::ObjectType,
	object_handle: u64,
	private_data_slot: vk::PrivateDataSlot,
	p_data: *mut u64,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_private_data
		.ok_or(CallError::MissingCommand("vkGetPrivateData"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			object_type,
			object_handle,
			private_data_slot,
			p_data,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkGetPrivateData` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPrivateData` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPrivateData")]
	#[doc = "\n\n[Khronos reference: `vkGetPrivateData`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPrivateData.html)"]
	#[inline]
	pub unsafe fn get_private_data(
		&self,
		object_type: vk::ObjectType,
		object_handle: u64,
		private_data_slot: vk::PrivateDataSlot,
		p_data: *mut u64,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_private_data(self, object_type, object_handle, private_data_slot, p_data) }
	}
}

/// Call `vkGetPrivateDataEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPrivateDataEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPrivateDataEXT")]
#[doc = "\n\n[Khronos reference: `vkGetPrivateDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPrivateDataEXT.html)"]
pub unsafe fn get_private_data_ext(
	device: &Device,
	object_type: vk::ObjectType,
	object_handle: u64,
	private_data_slot: vk::PrivateDataSlot,
	p_data: *mut u64,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_private_data_ext
		.ok_or(CallError::MissingCommand("vkGetPrivateDataEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			object_type,
			object_handle,
			private_data_slot,
			p_data,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkGetPrivateDataEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPrivateDataEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPrivateDataEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetPrivateDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPrivateDataEXT.html)"]
	#[inline]
	pub unsafe fn get_private_data_ext(
		&self,
		object_type: vk::ObjectType,
		object_handle: u64,
		private_data_slot: vk::PrivateDataSlot,
		p_data: *mut u64,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_private_data_ext(self, object_type, object_handle, private_data_slot, p_data) }
	}
}

/// Call `vkCmdCopyBuffer2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyBuffer2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdCopyBuffer2")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyBuffer2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyBuffer2.html)"]
pub unsafe fn cmd_copy_buffer2(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	copy_buffer_info: &vk::CopyBufferInfo2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_buffer2
		.ok_or(CallError::MissingCommand("vkCmdCopyBuffer2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, copy_buffer_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyBuffer2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyBuffer2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdCopyBuffer2")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyBuffer2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyBuffer2.html)"]
	#[inline]
	pub unsafe fn cmd_copy_buffer2(
		&self,
		command_buffer: vk::CommandBuffer,
		copy_buffer_info: &vk::CopyBufferInfo2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_buffer2(self, command_buffer, copy_buffer_info) }
	}
}

/// Call `vkCmdCopyBuffer2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyBuffer2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdCopyBuffer2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyBuffer2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyBuffer2KHR.html)"]
pub unsafe fn cmd_copy_buffer2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	copy_buffer_info: &vk::CopyBufferInfo2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_buffer2_khr
		.ok_or(CallError::MissingCommand("vkCmdCopyBuffer2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, copy_buffer_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyBuffer2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyBuffer2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdCopyBuffer2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyBuffer2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyBuffer2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_copy_buffer2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		copy_buffer_info: &vk::CopyBufferInfo2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_buffer2_khr(self, command_buffer, copy_buffer_info) }
	}
}

/// Call `vkCmdCopyImage2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyImage2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdCopyImage2")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyImage2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyImage2.html)"]
pub unsafe fn cmd_copy_image2(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	copy_image_info: &vk::CopyImageInfo2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_image2
		.ok_or(CallError::MissingCommand("vkCmdCopyImage2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, copy_image_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyImage2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyImage2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdCopyImage2")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyImage2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyImage2.html)"]
	#[inline]
	pub unsafe fn cmd_copy_image2(
		&self,
		command_buffer: vk::CommandBuffer,
		copy_image_info: &vk::CopyImageInfo2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_image2(self, command_buffer, copy_image_info) }
	}
}

/// Call `vkCmdCopyImage2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyImage2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdCopyImage2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyImage2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyImage2KHR.html)"]
pub unsafe fn cmd_copy_image2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	copy_image_info: &vk::CopyImageInfo2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_image2_khr
		.ok_or(CallError::MissingCommand("vkCmdCopyImage2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, copy_image_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyImage2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyImage2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdCopyImage2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyImage2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyImage2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_copy_image2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		copy_image_info: &vk::CopyImageInfo2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_image2_khr(self, command_buffer, copy_image_info) }
	}
}

/// Call `vkCmdBlitImage2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBlitImage2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdBlitImage2")]
#[doc = "\n\n[Khronos reference: `vkCmdBlitImage2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBlitImage2.html)"]
pub unsafe fn cmd_blit_image2(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	blit_image_info: &vk::BlitImageInfo2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_blit_image2
		.ok_or(CallError::MissingCommand("vkCmdBlitImage2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, blit_image_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBlitImage2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBlitImage2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdBlitImage2")]
	#[doc = "\n\n[Khronos reference: `vkCmdBlitImage2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBlitImage2.html)"]
	#[inline]
	pub unsafe fn cmd_blit_image2(
		&self,
		command_buffer: vk::CommandBuffer,
		blit_image_info: &vk::BlitImageInfo2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_blit_image2(self, command_buffer, blit_image_info) }
	}
}

/// Call `vkCmdBlitImage2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBlitImage2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdBlitImage2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdBlitImage2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBlitImage2KHR.html)"]
pub unsafe fn cmd_blit_image2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	blit_image_info: &vk::BlitImageInfo2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_blit_image2_khr
		.ok_or(CallError::MissingCommand("vkCmdBlitImage2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, blit_image_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBlitImage2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBlitImage2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdBlitImage2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdBlitImage2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBlitImage2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_blit_image2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		blit_image_info: &vk::BlitImageInfo2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_blit_image2_khr(self, command_buffer, blit_image_info) }
	}
}

/// Call `vkCmdCopyBufferToImage2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyBufferToImage2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdCopyBufferToImage2")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyBufferToImage2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyBufferToImage2.html)"]
pub unsafe fn cmd_copy_buffer_to_image2(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	copy_buffer_to_image_info: &vk::CopyBufferToImageInfo2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_buffer_to_image2
		.ok_or(CallError::MissingCommand("vkCmdCopyBufferToImage2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, copy_buffer_to_image_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyBufferToImage2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyBufferToImage2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdCopyBufferToImage2")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyBufferToImage2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyBufferToImage2.html)"]
	#[inline]
	pub unsafe fn cmd_copy_buffer_to_image2(
		&self,
		command_buffer: vk::CommandBuffer,
		copy_buffer_to_image_info: &vk::CopyBufferToImageInfo2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_buffer_to_image2(self, command_buffer, copy_buffer_to_image_info) }
	}
}

/// Call `vkCmdCopyBufferToImage2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyBufferToImage2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdCopyBufferToImage2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyBufferToImage2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyBufferToImage2KHR.html)"]
pub unsafe fn cmd_copy_buffer_to_image2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	copy_buffer_to_image_info: &vk::CopyBufferToImageInfo2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_buffer_to_image2_khr
		.ok_or(CallError::MissingCommand("vkCmdCopyBufferToImage2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, copy_buffer_to_image_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyBufferToImage2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyBufferToImage2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdCopyBufferToImage2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyBufferToImage2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyBufferToImage2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_copy_buffer_to_image2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		copy_buffer_to_image_info: &vk::CopyBufferToImageInfo2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_buffer_to_image2_khr(self, command_buffer, copy_buffer_to_image_info) }
	}
}

/// Call `vkCmdCopyImageToBuffer2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyImageToBuffer2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdCopyImageToBuffer2")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyImageToBuffer2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyImageToBuffer2.html)"]
pub unsafe fn cmd_copy_image_to_buffer2(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	copy_image_to_buffer_info: &vk::CopyImageToBufferInfo2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_image_to_buffer2
		.ok_or(CallError::MissingCommand("vkCmdCopyImageToBuffer2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, copy_image_to_buffer_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyImageToBuffer2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyImageToBuffer2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdCopyImageToBuffer2")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyImageToBuffer2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyImageToBuffer2.html)"]
	#[inline]
	pub unsafe fn cmd_copy_image_to_buffer2(
		&self,
		command_buffer: vk::CommandBuffer,
		copy_image_to_buffer_info: &vk::CopyImageToBufferInfo2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_image_to_buffer2(self, command_buffer, copy_image_to_buffer_info) }
	}
}

/// Call `vkCmdCopyImageToBuffer2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyImageToBuffer2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdCopyImageToBuffer2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyImageToBuffer2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyImageToBuffer2KHR.html)"]
pub unsafe fn cmd_copy_image_to_buffer2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	copy_image_to_buffer_info: &vk::CopyImageToBufferInfo2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_image_to_buffer2_khr
		.ok_or(CallError::MissingCommand("vkCmdCopyImageToBuffer2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, copy_image_to_buffer_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyImageToBuffer2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyImageToBuffer2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdCopyImageToBuffer2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyImageToBuffer2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyImageToBuffer2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_copy_image_to_buffer2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		copy_image_to_buffer_info: &vk::CopyImageToBufferInfo2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_image_to_buffer2_khr(self, command_buffer, copy_image_to_buffer_info) }
	}
}

/// Call `vkCmdResolveImage2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdResolveImage2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdResolveImage2")]
#[doc = "\n\n[Khronos reference: `vkCmdResolveImage2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdResolveImage2.html)"]
pub unsafe fn cmd_resolve_image2(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	resolve_image_info: &vk::ResolveImageInfo2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_resolve_image2
		.ok_or(CallError::MissingCommand("vkCmdResolveImage2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, resolve_image_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdResolveImage2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdResolveImage2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdResolveImage2")]
	#[doc = "\n\n[Khronos reference: `vkCmdResolveImage2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdResolveImage2.html)"]
	#[inline]
	pub unsafe fn cmd_resolve_image2(
		&self,
		command_buffer: vk::CommandBuffer,
		resolve_image_info: &vk::ResolveImageInfo2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_resolve_image2(self, command_buffer, resolve_image_info) }
	}
}

/// Call `vkCmdResolveImage2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdResolveImage2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdResolveImage2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdResolveImage2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdResolveImage2KHR.html)"]
pub unsafe fn cmd_resolve_image2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	resolve_image_info: &vk::ResolveImageInfo2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_resolve_image2_khr
		.ok_or(CallError::MissingCommand("vkCmdResolveImage2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, resolve_image_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdResolveImage2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdResolveImage2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdResolveImage2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdResolveImage2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdResolveImage2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_resolve_image2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		resolve_image_info: &vk::ResolveImageInfo2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_resolve_image2_khr(self, command_buffer, resolve_image_info) }
	}
}

/// Call `vkCmdSetFragmentShadingRateKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetFragmentShadingRateKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetFragmentShadingRateKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdSetFragmentShadingRateKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetFragmentShadingRateKHR.html)"]
pub unsafe fn cmd_set_fragment_shading_rate_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_fragment_size: *const vk::Extent2D,
	combiner_ops: *const vk::FragmentShadingRateCombinerOpKHR,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_fragment_shading_rate_khr
		.ok_or(CallError::MissingCommand("vkCmdSetFragmentShadingRateKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_fragment_size, combiner_ops) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetFragmentShadingRateKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetFragmentShadingRateKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetFragmentShadingRateKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetFragmentShadingRateKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetFragmentShadingRateKHR.html)"]
	#[inline]
	pub unsafe fn cmd_set_fragment_shading_rate_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_fragment_size: *const vk::Extent2D,
		combiner_ops: *const vk::FragmentShadingRateCombinerOpKHR,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_fragment_shading_rate_khr(self, command_buffer, p_fragment_size, combiner_ops)
		}
	}
}

/// Call `vkGetPhysicalDeviceFragmentShadingRatesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceFragmentShadingRatesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceFragmentShadingRatesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceFragmentShadingRatesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceFragmentShadingRatesKHR.html)"]
pub unsafe fn get_physical_device_fragment_shading_rates_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_fragment_shading_rate_count: *mut u32,
	p_fragment_shading_rates: *mut vk::PhysicalDeviceFragmentShadingRateKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_fragment_shading_rates_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceFragmentShadingRatesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			physical_device,
			p_fragment_shading_rate_count,
			p_fragment_shading_rates,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceFragmentShadingRatesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceFragmentShadingRatesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceFragmentShadingRatesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceFragmentShadingRatesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceFragmentShadingRatesKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_fragment_shading_rates_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		p_fragment_shading_rate_count: *mut u32,
		p_fragment_shading_rates: *mut vk::PhysicalDeviceFragmentShadingRateKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_fragment_shading_rates_khr(
				self,
				physical_device,
				p_fragment_shading_rate_count,
				p_fragment_shading_rates,
			)
		}
	}
}

/// Call `vkCmdSetFragmentShadingRateEnumNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetFragmentShadingRateEnumNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetFragmentShadingRateEnumNV")]
#[doc = "\n\n[Khronos reference: `vkCmdSetFragmentShadingRateEnumNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetFragmentShadingRateEnumNV.html)"]
pub unsafe fn cmd_set_fragment_shading_rate_enum_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	shading_rate: vk::FragmentShadingRateNV,
	combiner_ops: *const vk::FragmentShadingRateCombinerOpKHR,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_fragment_shading_rate_enum_nv
			.ok_or(CallError::MissingCommand(
				"vkCmdSetFragmentShadingRateEnumNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, shading_rate, combiner_ops) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetFragmentShadingRateEnumNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetFragmentShadingRateEnumNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetFragmentShadingRateEnumNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetFragmentShadingRateEnumNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetFragmentShadingRateEnumNV.html)"]
	#[inline]
	pub unsafe fn cmd_set_fragment_shading_rate_enum_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		shading_rate: vk::FragmentShadingRateNV,
		combiner_ops: *const vk::FragmentShadingRateCombinerOpKHR,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_fragment_shading_rate_enum_nv(self, command_buffer, shading_rate, combiner_ops)
		}
	}
}

/// Call `vkGetAccelerationStructureBuildSizesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetAccelerationStructureBuildSizesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetAccelerationStructureBuildSizesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetAccelerationStructureBuildSizesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetAccelerationStructureBuildSizesKHR.html)"]
pub unsafe fn get_acceleration_structure_build_sizes_khr(
	device: &Device,
	build_type: vk::AccelerationStructureBuildTypeKHR,
	p_build_info: *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
	p_max_primitive_counts: *const u32,
	p_size_info: *mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_acceleration_structure_build_sizes_khr
		.ok_or(CallError::MissingCommand(
			"vkGetAccelerationStructureBuildSizesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			build_type,
			p_build_info,
			p_max_primitive_counts,
			p_size_info,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkGetAccelerationStructureBuildSizesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetAccelerationStructureBuildSizesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetAccelerationStructureBuildSizesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetAccelerationStructureBuildSizesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetAccelerationStructureBuildSizesKHR.html)"]
	#[inline]
	pub unsafe fn get_acceleration_structure_build_sizes_khr(
		&self,
		build_type: vk::AccelerationStructureBuildTypeKHR,
		p_build_info: *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
		p_max_primitive_counts: *const u32,
		p_size_info: *mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_acceleration_structure_build_sizes_khr(
				self,
				build_type,
				p_build_info,
				p_max_primitive_counts,
				p_size_info,
			)
		}
	}
}

/// Call `vkCmdSetVertexInputEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetVertexInputEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetVertexInputEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetVertexInputEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetVertexInputEXT.html)"]
pub unsafe fn cmd_set_vertex_input_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	vertex_binding_description_count: u32,
	p_vertex_binding_descriptions: *const vk::VertexInputBindingDescription2EXT<'_>,
	vertex_attribute_description_count: u32,
	p_vertex_attribute_descriptions: *const vk::VertexInputAttributeDescription2EXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_vertex_input_ext
		.ok_or(CallError::MissingCommand("vkCmdSetVertexInputEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			vertex_binding_description_count,
			p_vertex_binding_descriptions,
			vertex_attribute_description_count,
			p_vertex_attribute_descriptions,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdSetVertexInputEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetVertexInputEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetVertexInputEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetVertexInputEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetVertexInputEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_vertex_input_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		vertex_binding_description_count: u32,
		p_vertex_binding_descriptions: *const vk::VertexInputBindingDescription2EXT<'_>,
		vertex_attribute_description_count: u32,
		p_vertex_attribute_descriptions: *const vk::VertexInputAttributeDescription2EXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_vertex_input_ext(
				self,
				command_buffer,
				vertex_binding_description_count,
				p_vertex_binding_descriptions,
				vertex_attribute_description_count,
				p_vertex_attribute_descriptions,
			)
		}
	}
}

/// Call `vkCmdSetColorWriteEnableEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetColorWriteEnableEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetColorWriteEnableEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetColorWriteEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetColorWriteEnableEXT.html)"]
pub unsafe fn cmd_set_color_write_enable_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	attachment_count: u32,
	p_color_write_enables: *const vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_color_write_enable_ext
		.ok_or(CallError::MissingCommand("vkCmdSetColorWriteEnableEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, attachment_count, p_color_write_enables) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetColorWriteEnableEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetColorWriteEnableEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetColorWriteEnableEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetColorWriteEnableEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetColorWriteEnableEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_color_write_enable_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		attachment_count: u32,
		p_color_write_enables: *const vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_color_write_enable_ext(
				self,
				command_buffer,
				attachment_count,
				p_color_write_enables,
			)
		}
	}
}

/// Call `vkCmdSetEvent2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetEvent2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdSetEvent2")]
#[doc = "\n\n[Khronos reference: `vkCmdSetEvent2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetEvent2.html)"]
pub unsafe fn cmd_set_event2(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	event: vk::Event,
	dependency_info: &vk::DependencyInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_event2
		.ok_or(CallError::MissingCommand("vkCmdSetEvent2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, event, dependency_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetEvent2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetEvent2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdSetEvent2")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetEvent2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetEvent2.html)"]
	#[inline]
	pub unsafe fn cmd_set_event2(
		&self,
		command_buffer: vk::CommandBuffer,
		event: vk::Event,
		dependency_info: &vk::DependencyInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_event2(self, command_buffer, event, dependency_info) }
	}
}

/// Call `vkCmdSetEvent2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetEvent2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdSetEvent2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdSetEvent2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetEvent2KHR.html)"]
pub unsafe fn cmd_set_event2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	event: vk::Event,
	dependency_info: &vk::DependencyInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_event2_khr
		.ok_or(CallError::MissingCommand("vkCmdSetEvent2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, event, dependency_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetEvent2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetEvent2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdSetEvent2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetEvent2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetEvent2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_set_event2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		event: vk::Event,
		dependency_info: &vk::DependencyInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_event2_khr(self, command_buffer, event, dependency_info) }
	}
}

/// Call `vkCmdResetEvent2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdResetEvent2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdResetEvent2")]
#[doc = "\n\n[Khronos reference: `vkCmdResetEvent2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdResetEvent2.html)"]
pub unsafe fn cmd_reset_event2(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	event: vk::Event,
	stage_mask: vk::PipelineStageFlags2,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_reset_event2
		.ok_or(CallError::MissingCommand("vkCmdResetEvent2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, event, stage_mask) };
	Ok(())
}

impl Device {
	/// Call `vkCmdResetEvent2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdResetEvent2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdResetEvent2")]
	#[doc = "\n\n[Khronos reference: `vkCmdResetEvent2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdResetEvent2.html)"]
	#[inline]
	pub unsafe fn cmd_reset_event2(
		&self,
		command_buffer: vk::CommandBuffer,
		event: vk::Event,
		stage_mask: vk::PipelineStageFlags2,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_reset_event2(self, command_buffer, event, stage_mask) }
	}
}

/// Call `vkCmdResetEvent2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdResetEvent2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdResetEvent2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdResetEvent2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdResetEvent2KHR.html)"]
pub unsafe fn cmd_reset_event2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	event: vk::Event,
	stage_mask: vk::PipelineStageFlags2,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_reset_event2_khr
		.ok_or(CallError::MissingCommand("vkCmdResetEvent2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, event, stage_mask) };
	Ok(())
}

impl Device {
	/// Call `vkCmdResetEvent2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdResetEvent2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdResetEvent2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdResetEvent2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdResetEvent2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_reset_event2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		event: vk::Event,
		stage_mask: vk::PipelineStageFlags2,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_reset_event2_khr(self, command_buffer, event, stage_mask) }
	}
}

/// Call `vkCmdWaitEvents2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdWaitEvents2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdWaitEvents2")]
#[doc = "\n\n[Khronos reference: `vkCmdWaitEvents2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWaitEvents2.html)"]
pub unsafe fn cmd_wait_events2(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	events: &[vk::Event],
	dependency_infos: &[vk::DependencyInfo<'_>],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_wait_events2
		.ok_or(CallError::MissingCommand("vkCmdWaitEvents2"))?;
	let event_count =
		u32::try_from(events.len()).map_err(|_| CallError::CountOverflow(events.len()))?;
	if dependency_infos.len() != events.len() {
		return Err(CallError::SliceLengthMismatch {
			parameter: "dependency_infos",
			expected: events.len(),
			actual: dependency_infos.len(),
		});
	}
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			event_count,
			events.as_ptr(),
			dependency_infos.as_ptr(),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdWaitEvents2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdWaitEvents2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdWaitEvents2")]
	#[doc = "\n\n[Khronos reference: `vkCmdWaitEvents2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWaitEvents2.html)"]
	#[inline]
	pub unsafe fn cmd_wait_events2(
		&self,
		command_buffer: vk::CommandBuffer,
		events: &[vk::Event],
		dependency_infos: &[vk::DependencyInfo<'_>],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_wait_events2(self, command_buffer, events, dependency_infos) }
	}
}

/// Call `vkCmdWaitEvents2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdWaitEvents2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdWaitEvents2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdWaitEvents2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWaitEvents2KHR.html)"]
pub unsafe fn cmd_wait_events2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	events: &[vk::Event],
	dependency_infos: &[vk::DependencyInfo<'_>],
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_wait_events2_khr
		.ok_or(CallError::MissingCommand("vkCmdWaitEvents2KHR"))?;
	let event_count =
		u32::try_from(events.len()).map_err(|_| CallError::CountOverflow(events.len()))?;
	if dependency_infos.len() != events.len() {
		return Err(CallError::SliceLengthMismatch {
			parameter: "dependency_infos",
			expected: events.len(),
			actual: dependency_infos.len(),
		});
	}
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			event_count,
			events.as_ptr(),
			dependency_infos.as_ptr(),
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdWaitEvents2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdWaitEvents2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdWaitEvents2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdWaitEvents2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWaitEvents2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_wait_events2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		events: &[vk::Event],
		dependency_infos: &[vk::DependencyInfo<'_>],
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_wait_events2_khr(self, command_buffer, events, dependency_infos) }
	}
}

/// Call `vkCmdPipelineBarrier2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdPipelineBarrier2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdPipelineBarrier2")]
#[doc = "\n\n[Khronos reference: `vkCmdPipelineBarrier2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPipelineBarrier2.html)"]
pub unsafe fn cmd_pipeline_barrier2(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	dependency_info: &vk::DependencyInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_pipeline_barrier2
		.ok_or(CallError::MissingCommand("vkCmdPipelineBarrier2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, dependency_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdPipelineBarrier2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdPipelineBarrier2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdPipelineBarrier2")]
	#[doc = "\n\n[Khronos reference: `vkCmdPipelineBarrier2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPipelineBarrier2.html)"]
	#[inline]
	pub unsafe fn cmd_pipeline_barrier2(
		&self,
		command_buffer: vk::CommandBuffer,
		dependency_info: &vk::DependencyInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_pipeline_barrier2(self, command_buffer, dependency_info) }
	}
}

/// Call `vkCmdPipelineBarrier2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdPipelineBarrier2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdPipelineBarrier2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdPipelineBarrier2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPipelineBarrier2KHR.html)"]
pub unsafe fn cmd_pipeline_barrier2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	dependency_info: &vk::DependencyInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_pipeline_barrier2_khr
		.ok_or(CallError::MissingCommand("vkCmdPipelineBarrier2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, dependency_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdPipelineBarrier2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdPipelineBarrier2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdPipelineBarrier2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdPipelineBarrier2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPipelineBarrier2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_pipeline_barrier2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		dependency_info: &vk::DependencyInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_pipeline_barrier2_khr(self, command_buffer, dependency_info) }
	}
}

/// Call `vkQueueSubmit2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkQueueSubmit2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkQueueSubmit2")]
#[doc = "\n\n[Khronos reference: `vkQueueSubmit2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueueSubmit2.html)"]
pub unsafe fn queue_submit2(
	device: &Device,
	queue: vk::Queue,
	submits: &[vk::SubmitInfo2<'_>],
	fence: vk::Fence,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.queue_submit2
		.ok_or(CallError::MissingCommand("vkQueueSubmit2"))?;
	let submit_count =
		u32::try_from(submits.len()).map_err(|_| CallError::CountOverflow(submits.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(queue, submit_count, submits.as_ptr(), fence) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkQueueSubmit2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkQueueSubmit2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkQueueSubmit2")]
	#[doc = "\n\n[Khronos reference: `vkQueueSubmit2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueueSubmit2.html)"]
	#[inline]
	pub unsafe fn queue_submit2(
		&self,
		queue: vk::Queue,
		submits: &[vk::SubmitInfo2<'_>],
		fence: vk::Fence,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { queue_submit2(self, queue, submits, fence) }
	}
}

/// Call `vkQueueSubmit2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkQueueSubmit2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkQueueSubmit2KHR")]
#[doc = "\n\n[Khronos reference: `vkQueueSubmit2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueueSubmit2KHR.html)"]
pub unsafe fn queue_submit2_khr(
	device: &Device,
	queue: vk::Queue,
	submits: &[vk::SubmitInfo2<'_>],
	fence: vk::Fence,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.queue_submit2_khr
		.ok_or(CallError::MissingCommand("vkQueueSubmit2KHR"))?;
	let submit_count =
		u32::try_from(submits.len()).map_err(|_| CallError::CountOverflow(submits.len()))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(queue, submit_count, submits.as_ptr(), fence) };
	if result != vk::Result::SUCCESS {
		return Err(CallError::Vulkan(result));
	}
	Ok(())
}

impl Device {
	/// Call `vkQueueSubmit2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkQueueSubmit2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkQueueSubmit2KHR")]
	#[doc = "\n\n[Khronos reference: `vkQueueSubmit2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueueSubmit2KHR.html)"]
	#[inline]
	pub unsafe fn queue_submit2_khr(
		&self,
		queue: vk::Queue,
		submits: &[vk::SubmitInfo2<'_>],
		fence: vk::Fence,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { queue_submit2_khr(self, queue, submits, fence) }
	}
}

/// Call `vkCmdWriteTimestamp2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdWriteTimestamp2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdWriteTimestamp2")]
#[doc = "\n\n[Khronos reference: `vkCmdWriteTimestamp2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWriteTimestamp2.html)"]
pub unsafe fn cmd_write_timestamp2(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	stage: vk::PipelineStageFlags2,
	query_pool: vk::QueryPool,
	query: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_write_timestamp2
		.ok_or(CallError::MissingCommand("vkCmdWriteTimestamp2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, stage, query_pool, query) };
	Ok(())
}

impl Device {
	/// Call `vkCmdWriteTimestamp2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdWriteTimestamp2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdWriteTimestamp2")]
	#[doc = "\n\n[Khronos reference: `vkCmdWriteTimestamp2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWriteTimestamp2.html)"]
	#[inline]
	pub unsafe fn cmd_write_timestamp2(
		&self,
		command_buffer: vk::CommandBuffer,
		stage: vk::PipelineStageFlags2,
		query_pool: vk::QueryPool,
		query: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_write_timestamp2(self, command_buffer, stage, query_pool, query) }
	}
}

/// Call `vkCmdWriteTimestamp2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command, invalid slice lengths/counts or a native error.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdWriteTimestamp2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
#[doc(alias = "vkCmdWriteTimestamp2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdWriteTimestamp2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWriteTimestamp2KHR.html)"]
pub unsafe fn cmd_write_timestamp2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	stage: vk::PipelineStageFlags2,
	query_pool: vk::QueryPool,
	query: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_write_timestamp2_khr
		.ok_or(CallError::MissingCommand("vkCmdWriteTimestamp2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, stage, query_pool, query) };
	Ok(())
}

impl Device {
	/// Call `vkCmdWriteTimestamp2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command, invalid slice lengths/counts or a native error.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdWriteTimestamp2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	#[doc(alias = "vkCmdWriteTimestamp2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdWriteTimestamp2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWriteTimestamp2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_write_timestamp2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		stage: vk::PipelineStageFlags2,
		query_pool: vk::QueryPool,
		query: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_write_timestamp2_khr(self, command_buffer, stage, query_pool, query) }
	}
}

/// Call `vkCmdWriteBufferMarker2AMD` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdWriteBufferMarker2AMD` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdWriteBufferMarker2AMD")]
#[doc = "\n\n[Khronos reference: `vkCmdWriteBufferMarker2AMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWriteBufferMarker2AMD.html)"]
pub unsafe fn cmd_write_buffer_marker2_amd(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	stage: vk::PipelineStageFlags2,
	dst_buffer: vk::Buffer,
	dst_offset: vk::DeviceSize,
	marker: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_write_buffer_marker2_amd
		.ok_or(CallError::MissingCommand("vkCmdWriteBufferMarker2AMD"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, stage, dst_buffer, dst_offset, marker) };
	Ok(())
}

impl Device {
	/// Call `vkCmdWriteBufferMarker2AMD` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdWriteBufferMarker2AMD` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdWriteBufferMarker2AMD")]
	#[doc = "\n\n[Khronos reference: `vkCmdWriteBufferMarker2AMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWriteBufferMarker2AMD.html)"]
	#[inline]
	pub unsafe fn cmd_write_buffer_marker2_amd(
		&self,
		command_buffer: vk::CommandBuffer,
		stage: vk::PipelineStageFlags2,
		dst_buffer: vk::Buffer,
		dst_offset: vk::DeviceSize,
		marker: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_write_buffer_marker2_amd(self, command_buffer, stage, dst_buffer, dst_offset, marker)
		}
	}
}

/// Call `vkGetQueueCheckpointData2NV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetQueueCheckpointData2NV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetQueueCheckpointData2NV")]
#[doc = "\n\n[Khronos reference: `vkGetQueueCheckpointData2NV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetQueueCheckpointData2NV.html)"]
pub unsafe fn get_queue_checkpoint_data2_nv(
	device: &Device,
	queue: vk::Queue,
	p_checkpoint_data_count: *mut u32,
	p_checkpoint_data: *mut vk::CheckpointData2NV<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_queue_checkpoint_data2_nv
		.ok_or(CallError::MissingCommand("vkGetQueueCheckpointData2NV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(queue, p_checkpoint_data_count, p_checkpoint_data) };
	Ok(())
}

impl Device {
	/// Call `vkGetQueueCheckpointData2NV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetQueueCheckpointData2NV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetQueueCheckpointData2NV")]
	#[doc = "\n\n[Khronos reference: `vkGetQueueCheckpointData2NV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetQueueCheckpointData2NV.html)"]
	#[inline]
	pub unsafe fn get_queue_checkpoint_data2_nv(
		&self,
		queue: vk::Queue,
		p_checkpoint_data_count: *mut u32,
		p_checkpoint_data: *mut vk::CheckpointData2NV<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_queue_checkpoint_data2_nv(self, queue, p_checkpoint_data_count, p_checkpoint_data)
		}
	}
}

/// Call `vkCopyMemoryToImage` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCopyMemoryToImage` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCopyMemoryToImage")]
#[doc = "\n\n[Khronos reference: `vkCopyMemoryToImage`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyMemoryToImage.html)"]
pub unsafe fn copy_memory_to_image(
	device: &Device,
	p_copy_memory_to_image_info: *const vk::CopyMemoryToImageInfo<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.copy_memory_to_image
		.ok_or(CallError::MissingCommand("vkCopyMemoryToImage"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_copy_memory_to_image_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCopyMemoryToImage` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCopyMemoryToImage` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCopyMemoryToImage")]
	#[doc = "\n\n[Khronos reference: `vkCopyMemoryToImage`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyMemoryToImage.html)"]
	#[inline]
	pub unsafe fn copy_memory_to_image(
		&self,
		p_copy_memory_to_image_info: *const vk::CopyMemoryToImageInfo<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { copy_memory_to_image(self, p_copy_memory_to_image_info) }
	}
}

/// Call `vkCopyMemoryToImageEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCopyMemoryToImageEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCopyMemoryToImageEXT")]
#[doc = "\n\n[Khronos reference: `vkCopyMemoryToImageEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyMemoryToImageEXT.html)"]
pub unsafe fn copy_memory_to_image_ext(
	device: &Device,
	p_copy_memory_to_image_info: *const vk::CopyMemoryToImageInfo<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.copy_memory_to_image_ext
		.ok_or(CallError::MissingCommand("vkCopyMemoryToImageEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_copy_memory_to_image_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCopyMemoryToImageEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCopyMemoryToImageEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCopyMemoryToImageEXT")]
	#[doc = "\n\n[Khronos reference: `vkCopyMemoryToImageEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyMemoryToImageEXT.html)"]
	#[inline]
	pub unsafe fn copy_memory_to_image_ext(
		&self,
		p_copy_memory_to_image_info: *const vk::CopyMemoryToImageInfo<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { copy_memory_to_image_ext(self, p_copy_memory_to_image_info) }
	}
}

/// Call `vkCopyImageToMemory` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCopyImageToMemory` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCopyImageToMemory")]
#[doc = "\n\n[Khronos reference: `vkCopyImageToMemory`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyImageToMemory.html)"]
pub unsafe fn copy_image_to_memory(
	device: &Device,
	p_copy_image_to_memory_info: *const vk::CopyImageToMemoryInfo<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.copy_image_to_memory
		.ok_or(CallError::MissingCommand("vkCopyImageToMemory"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_copy_image_to_memory_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCopyImageToMemory` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCopyImageToMemory` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCopyImageToMemory")]
	#[doc = "\n\n[Khronos reference: `vkCopyImageToMemory`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyImageToMemory.html)"]
	#[inline]
	pub unsafe fn copy_image_to_memory(
		&self,
		p_copy_image_to_memory_info: *const vk::CopyImageToMemoryInfo<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { copy_image_to_memory(self, p_copy_image_to_memory_info) }
	}
}

/// Call `vkCopyImageToMemoryEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCopyImageToMemoryEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCopyImageToMemoryEXT")]
#[doc = "\n\n[Khronos reference: `vkCopyImageToMemoryEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyImageToMemoryEXT.html)"]
pub unsafe fn copy_image_to_memory_ext(
	device: &Device,
	p_copy_image_to_memory_info: *const vk::CopyImageToMemoryInfo<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.copy_image_to_memory_ext
		.ok_or(CallError::MissingCommand("vkCopyImageToMemoryEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_copy_image_to_memory_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCopyImageToMemoryEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCopyImageToMemoryEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCopyImageToMemoryEXT")]
	#[doc = "\n\n[Khronos reference: `vkCopyImageToMemoryEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyImageToMemoryEXT.html)"]
	#[inline]
	pub unsafe fn copy_image_to_memory_ext(
		&self,
		p_copy_image_to_memory_info: *const vk::CopyImageToMemoryInfo<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { copy_image_to_memory_ext(self, p_copy_image_to_memory_info) }
	}
}

/// Call `vkCopyImageToImage` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCopyImageToImage` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCopyImageToImage")]
#[doc = "\n\n[Khronos reference: `vkCopyImageToImage`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyImageToImage.html)"]
pub unsafe fn copy_image_to_image(
	device: &Device,
	p_copy_image_to_image_info: *const vk::CopyImageToImageInfo<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.copy_image_to_image
		.ok_or(CallError::MissingCommand("vkCopyImageToImage"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_copy_image_to_image_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCopyImageToImage` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCopyImageToImage` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCopyImageToImage")]
	#[doc = "\n\n[Khronos reference: `vkCopyImageToImage`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyImageToImage.html)"]
	#[inline]
	pub unsafe fn copy_image_to_image(
		&self,
		p_copy_image_to_image_info: *const vk::CopyImageToImageInfo<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { copy_image_to_image(self, p_copy_image_to_image_info) }
	}
}

/// Call `vkCopyImageToImageEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCopyImageToImageEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCopyImageToImageEXT")]
#[doc = "\n\n[Khronos reference: `vkCopyImageToImageEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyImageToImageEXT.html)"]
pub unsafe fn copy_image_to_image_ext(
	device: &Device,
	p_copy_image_to_image_info: *const vk::CopyImageToImageInfo<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.copy_image_to_image_ext
		.ok_or(CallError::MissingCommand("vkCopyImageToImageEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_copy_image_to_image_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCopyImageToImageEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCopyImageToImageEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCopyImageToImageEXT")]
	#[doc = "\n\n[Khronos reference: `vkCopyImageToImageEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyImageToImageEXT.html)"]
	#[inline]
	pub unsafe fn copy_image_to_image_ext(
		&self,
		p_copy_image_to_image_info: *const vk::CopyImageToImageInfo<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { copy_image_to_image_ext(self, p_copy_image_to_image_info) }
	}
}

/// Call `vkTransitionImageLayout` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkTransitionImageLayout` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkTransitionImageLayout")]
#[doc = "\n\n[Khronos reference: `vkTransitionImageLayout`](https://docs.vulkan.org/refpages/latest/refpages/source/vkTransitionImageLayout.html)"]
pub unsafe fn transition_image_layout(
	device: &Device,
	transition_count: u32,
	p_transitions: *const vk::HostImageLayoutTransitionInfo<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.transition_image_layout
		.ok_or(CallError::MissingCommand("vkTransitionImageLayout"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), transition_count, p_transitions) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkTransitionImageLayout` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkTransitionImageLayout` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkTransitionImageLayout")]
	#[doc = "\n\n[Khronos reference: `vkTransitionImageLayout`](https://docs.vulkan.org/refpages/latest/refpages/source/vkTransitionImageLayout.html)"]
	#[inline]
	pub unsafe fn transition_image_layout(
		&self,
		transition_count: u32,
		p_transitions: *const vk::HostImageLayoutTransitionInfo<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { transition_image_layout(self, transition_count, p_transitions) }
	}
}

/// Call `vkTransitionImageLayoutEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkTransitionImageLayoutEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkTransitionImageLayoutEXT")]
#[doc = "\n\n[Khronos reference: `vkTransitionImageLayoutEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkTransitionImageLayoutEXT.html)"]
pub unsafe fn transition_image_layout_ext(
	device: &Device,
	transition_count: u32,
	p_transitions: *const vk::HostImageLayoutTransitionInfo<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.transition_image_layout_ext
		.ok_or(CallError::MissingCommand("vkTransitionImageLayoutEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), transition_count, p_transitions) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkTransitionImageLayoutEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkTransitionImageLayoutEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkTransitionImageLayoutEXT")]
	#[doc = "\n\n[Khronos reference: `vkTransitionImageLayoutEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkTransitionImageLayoutEXT.html)"]
	#[inline]
	pub unsafe fn transition_image_layout_ext(
		&self,
		transition_count: u32,
		p_transitions: *const vk::HostImageLayoutTransitionInfo<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { transition_image_layout_ext(self, transition_count, p_transitions) }
	}
}

/// Call `vkGetPhysicalDeviceVideoCapabilitiesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceVideoCapabilitiesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceVideoCapabilitiesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceVideoCapabilitiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceVideoCapabilitiesKHR.html)"]
pub unsafe fn get_physical_device_video_capabilities_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_video_profile: *const vk::VideoProfileInfoKHR<'_>,
	p_capabilities: *mut vk::VideoCapabilitiesKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_video_capabilities_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceVideoCapabilitiesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, p_video_profile, p_capabilities) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceVideoCapabilitiesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceVideoCapabilitiesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceVideoCapabilitiesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceVideoCapabilitiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceVideoCapabilitiesKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_video_capabilities_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		p_video_profile: *const vk::VideoProfileInfoKHR<'_>,
		p_capabilities: *mut vk::VideoCapabilitiesKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_video_capabilities_khr(
				self,
				physical_device,
				p_video_profile,
				p_capabilities,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceVideoFormatPropertiesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceVideoFormatPropertiesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceVideoFormatPropertiesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceVideoFormatPropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html)"]
pub unsafe fn get_physical_device_video_format_properties_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_video_format_info: *const vk::PhysicalDeviceVideoFormatInfoKHR<'_>,
	p_video_format_property_count: *mut u32,
	p_video_format_properties: *mut vk::VideoFormatPropertiesKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_video_format_properties_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceVideoFormatPropertiesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			physical_device,
			p_video_format_info,
			p_video_format_property_count,
			p_video_format_properties,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceVideoFormatPropertiesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceVideoFormatPropertiesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceVideoFormatPropertiesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceVideoFormatPropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_video_format_properties_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		p_video_format_info: *const vk::PhysicalDeviceVideoFormatInfoKHR<'_>,
		p_video_format_property_count: *mut u32,
		p_video_format_properties: *mut vk::VideoFormatPropertiesKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_video_format_properties_khr(
				self,
				physical_device,
				p_video_format_info,
				p_video_format_property_count,
				p_video_format_properties,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html)"]
pub unsafe fn get_physical_device_video_encode_quality_level_properties_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_quality_level_info: *const vk::PhysicalDeviceVideoEncodeQualityLevelInfoKHR<'_>,
	p_quality_level_properties: *mut vk::VideoEncodeQualityLevelPropertiesKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_video_encode_quality_level_properties_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			physical_device,
			p_quality_level_info,
			p_quality_level_properties,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_video_encode_quality_level_properties_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		p_quality_level_info: *const vk::PhysicalDeviceVideoEncodeQualityLevelInfoKHR<'_>,
		p_quality_level_properties: *mut vk::VideoEncodeQualityLevelPropertiesKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_video_encode_quality_level_properties_khr(
				self,
				physical_device,
				p_quality_level_info,
				p_quality_level_properties,
			)
		}
	}
}

/// Call `vkCreateVideoSessionKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateVideoSessionKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateVideoSessionKHR")]
#[doc = "\n\n[Khronos reference: `vkCreateVideoSessionKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateVideoSessionKHR.html)"]
pub unsafe fn create_video_session_khr(
	device: &Device,
	p_create_info: *const vk::VideoSessionCreateInfoKHR<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_video_session: *mut vk::VideoSessionKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_video_session_khr
		.ok_or(CallError::MissingCommand("vkCreateVideoSessionKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result =
		unsafe { __vk_function(device.handle(), p_create_info, p_allocator, p_video_session) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateVideoSessionKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateVideoSessionKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateVideoSessionKHR")]
	#[doc = "\n\n[Khronos reference: `vkCreateVideoSessionKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateVideoSessionKHR.html)"]
	#[inline]
	pub unsafe fn create_video_session_khr(
		&self,
		p_create_info: *const vk::VideoSessionCreateInfoKHR<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_video_session: *mut vk::VideoSessionKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_video_session_khr(self, p_create_info, p_allocator, p_video_session) }
	}
}

/// Call `vkDestroyVideoSessionKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyVideoSessionKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyVideoSessionKHR")]
#[doc = "\n\n[Khronos reference: `vkDestroyVideoSessionKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyVideoSessionKHR.html)"]
pub unsafe fn destroy_video_session_khr(
	device: &Device,
	video_session: vk::VideoSessionKHR,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_video_session_khr
		.ok_or(CallError::MissingCommand("vkDestroyVideoSessionKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), video_session, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyVideoSessionKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyVideoSessionKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyVideoSessionKHR")]
	#[doc = "\n\n[Khronos reference: `vkDestroyVideoSessionKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyVideoSessionKHR.html)"]
	#[inline]
	pub unsafe fn destroy_video_session_khr(
		&self,
		video_session: vk::VideoSessionKHR,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_video_session_khr(self, video_session, p_allocator) }
	}
}

/// Call `vkCreateVideoSessionParametersKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateVideoSessionParametersKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateVideoSessionParametersKHR")]
#[doc = "\n\n[Khronos reference: `vkCreateVideoSessionParametersKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateVideoSessionParametersKHR.html)"]
pub unsafe fn create_video_session_parameters_khr(
	device: &Device,
	p_create_info: *const vk::VideoSessionParametersCreateInfoKHR<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_video_session_parameters: *mut vk::VideoSessionParametersKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.create_video_session_parameters_khr
			.ok_or(CallError::MissingCommand(
				"vkCreateVideoSessionParametersKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_create_info,
			p_allocator,
			p_video_session_parameters,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateVideoSessionParametersKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateVideoSessionParametersKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateVideoSessionParametersKHR")]
	#[doc = "\n\n[Khronos reference: `vkCreateVideoSessionParametersKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateVideoSessionParametersKHR.html)"]
	#[inline]
	pub unsafe fn create_video_session_parameters_khr(
		&self,
		p_create_info: *const vk::VideoSessionParametersCreateInfoKHR<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_video_session_parameters: *mut vk::VideoSessionParametersKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			create_video_session_parameters_khr(
				self,
				p_create_info,
				p_allocator,
				p_video_session_parameters,
			)
		}
	}
}

/// Call `vkUpdateVideoSessionParametersKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkUpdateVideoSessionParametersKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkUpdateVideoSessionParametersKHR")]
#[doc = "\n\n[Khronos reference: `vkUpdateVideoSessionParametersKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkUpdateVideoSessionParametersKHR.html)"]
pub unsafe fn update_video_session_parameters_khr(
	device: &Device,
	video_session_parameters: vk::VideoSessionParametersKHR,
	p_update_info: *const vk::VideoSessionParametersUpdateInfoKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.update_video_session_parameters_khr
			.ok_or(CallError::MissingCommand(
				"vkUpdateVideoSessionParametersKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), video_session_parameters, p_update_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkUpdateVideoSessionParametersKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkUpdateVideoSessionParametersKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkUpdateVideoSessionParametersKHR")]
	#[doc = "\n\n[Khronos reference: `vkUpdateVideoSessionParametersKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkUpdateVideoSessionParametersKHR.html)"]
	#[inline]
	pub unsafe fn update_video_session_parameters_khr(
		&self,
		video_session_parameters: vk::VideoSessionParametersKHR,
		p_update_info: *const vk::VideoSessionParametersUpdateInfoKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { update_video_session_parameters_khr(self, video_session_parameters, p_update_info) }
	}
}

/// Call `vkGetEncodedVideoSessionParametersKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetEncodedVideoSessionParametersKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetEncodedVideoSessionParametersKHR")]
#[doc = "\n\n[Khronos reference: `vkGetEncodedVideoSessionParametersKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetEncodedVideoSessionParametersKHR.html)"]
pub unsafe fn get_encoded_video_session_parameters_khr(
	device: &Device,
	p_video_session_parameters_info: *const vk::VideoEncodeSessionParametersGetInfoKHR<'_>,
	p_feedback_info: *mut vk::VideoEncodeSessionParametersFeedbackInfoKHR<'_>,
	p_data_size: *mut usize,
	p_data: *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.get_encoded_video_session_parameters_khr
			.ok_or(CallError::MissingCommand(
				"vkGetEncodedVideoSessionParametersKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_video_session_parameters_info,
			p_feedback_info,
			p_data_size,
			p_data,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetEncodedVideoSessionParametersKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetEncodedVideoSessionParametersKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetEncodedVideoSessionParametersKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetEncodedVideoSessionParametersKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetEncodedVideoSessionParametersKHR.html)"]
	#[inline]
	pub unsafe fn get_encoded_video_session_parameters_khr(
		&self,
		p_video_session_parameters_info: *const vk::VideoEncodeSessionParametersGetInfoKHR<'_>,
		p_feedback_info: *mut vk::VideoEncodeSessionParametersFeedbackInfoKHR<'_>,
		p_data_size: *mut usize,
		p_data: *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_encoded_video_session_parameters_khr(
				self,
				p_video_session_parameters_info,
				p_feedback_info,
				p_data_size,
				p_data,
			)
		}
	}
}

/// Call `vkDestroyVideoSessionParametersKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyVideoSessionParametersKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyVideoSessionParametersKHR")]
#[doc = "\n\n[Khronos reference: `vkDestroyVideoSessionParametersKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyVideoSessionParametersKHR.html)"]
pub unsafe fn destroy_video_session_parameters_khr(
	device: &Device,
	video_session_parameters: vk::VideoSessionParametersKHR,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.destroy_video_session_parameters_khr
			.ok_or(CallError::MissingCommand(
				"vkDestroyVideoSessionParametersKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), video_session_parameters, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyVideoSessionParametersKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyVideoSessionParametersKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyVideoSessionParametersKHR")]
	#[doc = "\n\n[Khronos reference: `vkDestroyVideoSessionParametersKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyVideoSessionParametersKHR.html)"]
	#[inline]
	pub unsafe fn destroy_video_session_parameters_khr(
		&self,
		video_session_parameters: vk::VideoSessionParametersKHR,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_video_session_parameters_khr(self, video_session_parameters, p_allocator) }
	}
}

/// Call `vkGetVideoSessionMemoryRequirementsKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetVideoSessionMemoryRequirementsKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetVideoSessionMemoryRequirementsKHR")]
#[doc = "\n\n[Khronos reference: `vkGetVideoSessionMemoryRequirementsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetVideoSessionMemoryRequirementsKHR.html)"]
pub unsafe fn get_video_session_memory_requirements_khr(
	device: &Device,
	video_session: vk::VideoSessionKHR,
	p_memory_requirements_count: *mut u32,
	p_memory_requirements: *mut vk::VideoSessionMemoryRequirementsKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_video_session_memory_requirements_khr
		.ok_or(CallError::MissingCommand(
			"vkGetVideoSessionMemoryRequirementsKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			video_session,
			p_memory_requirements_count,
			p_memory_requirements,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetVideoSessionMemoryRequirementsKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetVideoSessionMemoryRequirementsKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetVideoSessionMemoryRequirementsKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetVideoSessionMemoryRequirementsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetVideoSessionMemoryRequirementsKHR.html)"]
	#[inline]
	pub unsafe fn get_video_session_memory_requirements_khr(
		&self,
		video_session: vk::VideoSessionKHR,
		p_memory_requirements_count: *mut u32,
		p_memory_requirements: *mut vk::VideoSessionMemoryRequirementsKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_video_session_memory_requirements_khr(
				self,
				video_session,
				p_memory_requirements_count,
				p_memory_requirements,
			)
		}
	}
}

/// Call `vkBindVideoSessionMemoryKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkBindVideoSessionMemoryKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkBindVideoSessionMemoryKHR")]
#[doc = "\n\n[Khronos reference: `vkBindVideoSessionMemoryKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBindVideoSessionMemoryKHR.html)"]
pub unsafe fn bind_video_session_memory_khr(
	device: &Device,
	video_session: vk::VideoSessionKHR,
	bind_session_memory_info_count: u32,
	p_bind_session_memory_infos: *const vk::BindVideoSessionMemoryInfoKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.bind_video_session_memory_khr
		.ok_or(CallError::MissingCommand("vkBindVideoSessionMemoryKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			video_session,
			bind_session_memory_info_count,
			p_bind_session_memory_infos,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkBindVideoSessionMemoryKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkBindVideoSessionMemoryKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkBindVideoSessionMemoryKHR")]
	#[doc = "\n\n[Khronos reference: `vkBindVideoSessionMemoryKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBindVideoSessionMemoryKHR.html)"]
	#[inline]
	pub unsafe fn bind_video_session_memory_khr(
		&self,
		video_session: vk::VideoSessionKHR,
		bind_session_memory_info_count: u32,
		p_bind_session_memory_infos: *const vk::BindVideoSessionMemoryInfoKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			bind_video_session_memory_khr(
				self,
				video_session,
				bind_session_memory_info_count,
				p_bind_session_memory_infos,
			)
		}
	}
}

/// Call `vkCmdDecodeVideoKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDecodeVideoKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDecodeVideoKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdDecodeVideoKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDecodeVideoKHR.html)"]
pub unsafe fn cmd_decode_video_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_decode_info: *const vk::VideoDecodeInfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_decode_video_khr
		.ok_or(CallError::MissingCommand("vkCmdDecodeVideoKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_decode_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDecodeVideoKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDecodeVideoKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDecodeVideoKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdDecodeVideoKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDecodeVideoKHR.html)"]
	#[inline]
	pub unsafe fn cmd_decode_video_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_decode_info: *const vk::VideoDecodeInfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_decode_video_khr(self, command_buffer, p_decode_info) }
	}
}

/// Call `vkCmdBeginVideoCodingKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBeginVideoCodingKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBeginVideoCodingKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdBeginVideoCodingKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginVideoCodingKHR.html)"]
pub unsafe fn cmd_begin_video_coding_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_begin_info: *const vk::VideoBeginCodingInfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_begin_video_coding_khr
		.ok_or(CallError::MissingCommand("vkCmdBeginVideoCodingKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_begin_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBeginVideoCodingKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBeginVideoCodingKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBeginVideoCodingKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdBeginVideoCodingKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginVideoCodingKHR.html)"]
	#[inline]
	pub unsafe fn cmd_begin_video_coding_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_begin_info: *const vk::VideoBeginCodingInfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_begin_video_coding_khr(self, command_buffer, p_begin_info) }
	}
}

/// Call `vkCmdControlVideoCodingKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdControlVideoCodingKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdControlVideoCodingKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdControlVideoCodingKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdControlVideoCodingKHR.html)"]
pub unsafe fn cmd_control_video_coding_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_coding_control_info: *const vk::VideoCodingControlInfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_control_video_coding_khr
		.ok_or(CallError::MissingCommand("vkCmdControlVideoCodingKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_coding_control_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdControlVideoCodingKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdControlVideoCodingKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdControlVideoCodingKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdControlVideoCodingKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdControlVideoCodingKHR.html)"]
	#[inline]
	pub unsafe fn cmd_control_video_coding_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_coding_control_info: *const vk::VideoCodingControlInfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_control_video_coding_khr(self, command_buffer, p_coding_control_info) }
	}
}

/// Call `vkCmdEndVideoCodingKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdEndVideoCodingKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdEndVideoCodingKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdEndVideoCodingKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndVideoCodingKHR.html)"]
pub unsafe fn cmd_end_video_coding_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_end_coding_info: *const vk::VideoEndCodingInfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_end_video_coding_khr
		.ok_or(CallError::MissingCommand("vkCmdEndVideoCodingKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_end_coding_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdEndVideoCodingKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdEndVideoCodingKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdEndVideoCodingKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdEndVideoCodingKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndVideoCodingKHR.html)"]
	#[inline]
	pub unsafe fn cmd_end_video_coding_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_end_coding_info: *const vk::VideoEndCodingInfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_end_video_coding_khr(self, command_buffer, p_end_coding_info) }
	}
}

/// Call `vkCmdEncodeVideoKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdEncodeVideoKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdEncodeVideoKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdEncodeVideoKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEncodeVideoKHR.html)"]
pub unsafe fn cmd_encode_video_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_encode_info: *const vk::VideoEncodeInfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_encode_video_khr
		.ok_or(CallError::MissingCommand("vkCmdEncodeVideoKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_encode_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdEncodeVideoKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdEncodeVideoKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdEncodeVideoKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdEncodeVideoKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEncodeVideoKHR.html)"]
	#[inline]
	pub unsafe fn cmd_encode_video_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_encode_info: *const vk::VideoEncodeInfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_encode_video_khr(self, command_buffer, p_encode_info) }
	}
}

/// Call `vkCmdDecompressMemoryNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDecompressMemoryNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDecompressMemoryNV")]
#[doc = "\n\n[Khronos reference: `vkCmdDecompressMemoryNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDecompressMemoryNV.html)"]
pub unsafe fn cmd_decompress_memory_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	decompress_region_count: u32,
	p_decompress_memory_regions: *const vk::DecompressMemoryRegionNV,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_decompress_memory_nv
		.ok_or(CallError::MissingCommand("vkCmdDecompressMemoryNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			decompress_region_count,
			p_decompress_memory_regions,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdDecompressMemoryNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDecompressMemoryNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDecompressMemoryNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdDecompressMemoryNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDecompressMemoryNV.html)"]
	#[inline]
	pub unsafe fn cmd_decompress_memory_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		decompress_region_count: u32,
		p_decompress_memory_regions: *const vk::DecompressMemoryRegionNV,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_decompress_memory_nv(
				self,
				command_buffer,
				decompress_region_count,
				p_decompress_memory_regions,
			)
		}
	}
}

/// Call `vkCmdDecompressMemoryIndirectCountNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDecompressMemoryIndirectCountNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDecompressMemoryIndirectCountNV")]
#[doc = "\n\n[Khronos reference: `vkCmdDecompressMemoryIndirectCountNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDecompressMemoryIndirectCountNV.html)"]
pub unsafe fn cmd_decompress_memory_indirect_count_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	indirect_commands_address: vk::DeviceAddress,
	indirect_commands_count_address: vk::DeviceAddress,
	stride: u32,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_decompress_memory_indirect_count_nv
			.ok_or(CallError::MissingCommand(
				"vkCmdDecompressMemoryIndirectCountNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			indirect_commands_address,
			indirect_commands_count_address,
			stride,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdDecompressMemoryIndirectCountNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDecompressMemoryIndirectCountNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDecompressMemoryIndirectCountNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdDecompressMemoryIndirectCountNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDecompressMemoryIndirectCountNV.html)"]
	#[inline]
	pub unsafe fn cmd_decompress_memory_indirect_count_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		indirect_commands_address: vk::DeviceAddress,
		indirect_commands_count_address: vk::DeviceAddress,
		stride: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_decompress_memory_indirect_count_nv(
				self,
				command_buffer,
				indirect_commands_address,
				indirect_commands_count_address,
				stride,
			)
		}
	}
}

/// Call `vkGetPartitionedAccelerationStructuresBuildSizesNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPartitionedAccelerationStructuresBuildSizesNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPartitionedAccelerationStructuresBuildSizesNV")]
#[doc = "\n\n[Khronos reference: `vkGetPartitionedAccelerationStructuresBuildSizesNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPartitionedAccelerationStructuresBuildSizesNV.html)"]
pub unsafe fn get_partitioned_acceleration_structures_build_sizes_nv(
	device: &Device,
	p_info: *const vk::PartitionedAccelerationStructureInstancesInputNV<'_>,
	p_size_info: *mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_partitioned_acceleration_structures_build_sizes_nv
		.ok_or(CallError::MissingCommand(
			"vkGetPartitionedAccelerationStructuresBuildSizesNV",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_info, p_size_info) };
	Ok(())
}

impl Device {
	/// Call `vkGetPartitionedAccelerationStructuresBuildSizesNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPartitionedAccelerationStructuresBuildSizesNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPartitionedAccelerationStructuresBuildSizesNV")]
	#[doc = "\n\n[Khronos reference: `vkGetPartitionedAccelerationStructuresBuildSizesNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPartitionedAccelerationStructuresBuildSizesNV.html)"]
	#[inline]
	pub unsafe fn get_partitioned_acceleration_structures_build_sizes_nv(
		&self,
		p_info: *const vk::PartitionedAccelerationStructureInstancesInputNV<'_>,
		p_size_info: *mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_partitioned_acceleration_structures_build_sizes_nv(self, p_info, p_size_info) }
	}
}

/// Call `vkCmdBuildPartitionedAccelerationStructuresNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBuildPartitionedAccelerationStructuresNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBuildPartitionedAccelerationStructuresNV")]
#[doc = "\n\n[Khronos reference: `vkCmdBuildPartitionedAccelerationStructuresNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBuildPartitionedAccelerationStructuresNV.html)"]
pub unsafe fn cmd_build_partitioned_acceleration_structures_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_build_info: *const vk::BuildPartitionedAccelerationStructureInfoNV<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_build_partitioned_acceleration_structures_nv
		.ok_or(CallError::MissingCommand(
			"vkCmdBuildPartitionedAccelerationStructuresNV",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_build_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBuildPartitionedAccelerationStructuresNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBuildPartitionedAccelerationStructuresNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBuildPartitionedAccelerationStructuresNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdBuildPartitionedAccelerationStructuresNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBuildPartitionedAccelerationStructuresNV.html)"]
	#[inline]
	pub unsafe fn cmd_build_partitioned_acceleration_structures_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		p_build_info: *const vk::BuildPartitionedAccelerationStructureInfoNV<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_build_partitioned_acceleration_structures_nv(self, command_buffer, p_build_info) }
	}
}

/// Call `vkCmdDecompressMemoryEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDecompressMemoryEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDecompressMemoryEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdDecompressMemoryEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDecompressMemoryEXT.html)"]
pub unsafe fn cmd_decompress_memory_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_decompress_memory_info_ext: *const vk::DecompressMemoryInfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_decompress_memory_ext
		.ok_or(CallError::MissingCommand("vkCmdDecompressMemoryEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_decompress_memory_info_ext) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDecompressMemoryEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDecompressMemoryEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDecompressMemoryEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdDecompressMemoryEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDecompressMemoryEXT.html)"]
	#[inline]
	pub unsafe fn cmd_decompress_memory_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_decompress_memory_info_ext: *const vk::DecompressMemoryInfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_decompress_memory_ext(self, command_buffer, p_decompress_memory_info_ext) }
	}
}

/// Call `vkCmdDecompressMemoryIndirectCountEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDecompressMemoryIndirectCountEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDecompressMemoryIndirectCountEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdDecompressMemoryIndirectCountEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDecompressMemoryIndirectCountEXT.html)"]
pub unsafe fn cmd_decompress_memory_indirect_count_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	decompression_method: vk::MemoryDecompressionMethodFlagsEXT,
	indirect_commands_address: vk::DeviceAddress,
	indirect_commands_count_address: vk::DeviceAddress,
	max_decompression_count: u32,
	stride: u32,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_decompress_memory_indirect_count_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdDecompressMemoryIndirectCountEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			decompression_method,
			indirect_commands_address,
			indirect_commands_count_address,
			max_decompression_count,
			stride,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdDecompressMemoryIndirectCountEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDecompressMemoryIndirectCountEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDecompressMemoryIndirectCountEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdDecompressMemoryIndirectCountEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDecompressMemoryIndirectCountEXT.html)"]
	#[inline]
	pub unsafe fn cmd_decompress_memory_indirect_count_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		decompression_method: vk::MemoryDecompressionMethodFlagsEXT,
		indirect_commands_address: vk::DeviceAddress,
		indirect_commands_count_address: vk::DeviceAddress,
		max_decompression_count: u32,
		stride: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_decompress_memory_indirect_count_ext(
				self,
				command_buffer,
				decompression_method,
				indirect_commands_address,
				indirect_commands_count_address,
				max_decompression_count,
				stride,
			)
		}
	}
}

/// Call `vkCreateCuModuleNVX` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateCuModuleNVX` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateCuModuleNVX")]
#[doc = "\n\n[Khronos reference: `vkCreateCuModuleNVX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateCuModuleNVX.html)"]
pub unsafe fn create_cu_module_nvx(
	device: &Device,
	p_create_info: *const vk::CuModuleCreateInfoNVX<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_module: *mut vk::CuModuleNVX,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_cu_module_nvx
		.ok_or(CallError::MissingCommand("vkCreateCuModuleNVX"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_create_info, p_allocator, p_module) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateCuModuleNVX` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateCuModuleNVX` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateCuModuleNVX")]
	#[doc = "\n\n[Khronos reference: `vkCreateCuModuleNVX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateCuModuleNVX.html)"]
	#[inline]
	pub unsafe fn create_cu_module_nvx(
		&self,
		p_create_info: *const vk::CuModuleCreateInfoNVX<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_module: *mut vk::CuModuleNVX,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_cu_module_nvx(self, p_create_info, p_allocator, p_module) }
	}
}

/// Call `vkCreateCuFunctionNVX` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateCuFunctionNVX` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateCuFunctionNVX")]
#[doc = "\n\n[Khronos reference: `vkCreateCuFunctionNVX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateCuFunctionNVX.html)"]
pub unsafe fn create_cu_function_nvx(
	device: &Device,
	p_create_info: *const vk::CuFunctionCreateInfoNVX<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_function: *mut vk::CuFunctionNVX,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_cu_function_nvx
		.ok_or(CallError::MissingCommand("vkCreateCuFunctionNVX"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_create_info, p_allocator, p_function) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateCuFunctionNVX` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateCuFunctionNVX` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateCuFunctionNVX")]
	#[doc = "\n\n[Khronos reference: `vkCreateCuFunctionNVX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateCuFunctionNVX.html)"]
	#[inline]
	pub unsafe fn create_cu_function_nvx(
		&self,
		p_create_info: *const vk::CuFunctionCreateInfoNVX<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_function: *mut vk::CuFunctionNVX,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_cu_function_nvx(self, p_create_info, p_allocator, p_function) }
	}
}

/// Call `vkDestroyCuModuleNVX` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyCuModuleNVX` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyCuModuleNVX")]
#[doc = "\n\n[Khronos reference: `vkDestroyCuModuleNVX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyCuModuleNVX.html)"]
pub unsafe fn destroy_cu_module_nvx(
	device: &Device,
	module: vk::CuModuleNVX,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_cu_module_nvx
		.ok_or(CallError::MissingCommand("vkDestroyCuModuleNVX"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), module, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyCuModuleNVX` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyCuModuleNVX` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyCuModuleNVX")]
	#[doc = "\n\n[Khronos reference: `vkDestroyCuModuleNVX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyCuModuleNVX.html)"]
	#[inline]
	pub unsafe fn destroy_cu_module_nvx(
		&self,
		module: vk::CuModuleNVX,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_cu_module_nvx(self, module, p_allocator) }
	}
}

/// Call `vkDestroyCuFunctionNVX` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyCuFunctionNVX` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyCuFunctionNVX")]
#[doc = "\n\n[Khronos reference: `vkDestroyCuFunctionNVX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyCuFunctionNVX.html)"]
pub unsafe fn destroy_cu_function_nvx(
	device: &Device,
	function: vk::CuFunctionNVX,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_cu_function_nvx
		.ok_or(CallError::MissingCommand("vkDestroyCuFunctionNVX"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), function, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyCuFunctionNVX` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyCuFunctionNVX` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyCuFunctionNVX")]
	#[doc = "\n\n[Khronos reference: `vkDestroyCuFunctionNVX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyCuFunctionNVX.html)"]
	#[inline]
	pub unsafe fn destroy_cu_function_nvx(
		&self,
		function: vk::CuFunctionNVX,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_cu_function_nvx(self, function, p_allocator) }
	}
}

/// Call `vkCmdCuLaunchKernelNVX` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCuLaunchKernelNVX` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdCuLaunchKernelNVX")]
#[doc = "\n\n[Khronos reference: `vkCmdCuLaunchKernelNVX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCuLaunchKernelNVX.html)"]
pub unsafe fn cmd_cu_launch_kernel_nvx(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_launch_info: *const vk::CuLaunchInfoNVX<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_cu_launch_kernel_nvx
		.ok_or(CallError::MissingCommand("vkCmdCuLaunchKernelNVX"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_launch_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCuLaunchKernelNVX` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCuLaunchKernelNVX` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdCuLaunchKernelNVX")]
	#[doc = "\n\n[Khronos reference: `vkCmdCuLaunchKernelNVX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCuLaunchKernelNVX.html)"]
	#[inline]
	pub unsafe fn cmd_cu_launch_kernel_nvx(
		&self,
		command_buffer: vk::CommandBuffer,
		p_launch_info: *const vk::CuLaunchInfoNVX<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_cu_launch_kernel_nvx(self, command_buffer, p_launch_info) }
	}
}

/// Call `vkGetDescriptorSetLayoutSizeEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDescriptorSetLayoutSizeEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDescriptorSetLayoutSizeEXT")]
#[doc = "\n\n[Khronos reference: `vkGetDescriptorSetLayoutSizeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDescriptorSetLayoutSizeEXT.html)"]
pub unsafe fn get_descriptor_set_layout_size_ext(
	device: &Device,
	layout: vk::DescriptorSetLayout,
	p_layout_size_in_bytes: *mut vk::DeviceSize,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_descriptor_set_layout_size_ext
		.ok_or(CallError::MissingCommand("vkGetDescriptorSetLayoutSizeEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), layout, p_layout_size_in_bytes) };
	Ok(())
}

impl Device {
	/// Call `vkGetDescriptorSetLayoutSizeEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDescriptorSetLayoutSizeEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDescriptorSetLayoutSizeEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetDescriptorSetLayoutSizeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDescriptorSetLayoutSizeEXT.html)"]
	#[inline]
	pub unsafe fn get_descriptor_set_layout_size_ext(
		&self,
		layout: vk::DescriptorSetLayout,
		p_layout_size_in_bytes: *mut vk::DeviceSize,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_descriptor_set_layout_size_ext(self, layout, p_layout_size_in_bytes) }
	}
}

/// Call `vkGetDescriptorSetLayoutBindingOffsetEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDescriptorSetLayoutBindingOffsetEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDescriptorSetLayoutBindingOffsetEXT")]
#[doc = "\n\n[Khronos reference: `vkGetDescriptorSetLayoutBindingOffsetEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDescriptorSetLayoutBindingOffsetEXT.html)"]
pub unsafe fn get_descriptor_set_layout_binding_offset_ext(
	device: &Device,
	layout: vk::DescriptorSetLayout,
	binding: u32,
	p_offset: *mut vk::DeviceSize,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_descriptor_set_layout_binding_offset_ext
		.ok_or(CallError::MissingCommand(
			"vkGetDescriptorSetLayoutBindingOffsetEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), layout, binding, p_offset) };
	Ok(())
}

impl Device {
	/// Call `vkGetDescriptorSetLayoutBindingOffsetEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDescriptorSetLayoutBindingOffsetEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDescriptorSetLayoutBindingOffsetEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetDescriptorSetLayoutBindingOffsetEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDescriptorSetLayoutBindingOffsetEXT.html)"]
	#[inline]
	pub unsafe fn get_descriptor_set_layout_binding_offset_ext(
		&self,
		layout: vk::DescriptorSetLayout,
		binding: u32,
		p_offset: *mut vk::DeviceSize,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_descriptor_set_layout_binding_offset_ext(self, layout, binding, p_offset) }
	}
}

/// Call `vkGetDescriptorEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDescriptorEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDescriptorEXT")]
#[doc = "\n\n[Khronos reference: `vkGetDescriptorEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDescriptorEXT.html)"]
pub unsafe fn get_descriptor_ext(
	device: &Device,
	p_descriptor_info: *const vk::DescriptorGetInfoEXT<'_>,
	data_size: usize,
	p_descriptor: *mut std::ffi::c_void,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_descriptor_ext
		.ok_or(CallError::MissingCommand("vkGetDescriptorEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_descriptor_info, data_size, p_descriptor) };
	Ok(())
}

impl Device {
	/// Call `vkGetDescriptorEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDescriptorEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDescriptorEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetDescriptorEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDescriptorEXT.html)"]
	#[inline]
	pub unsafe fn get_descriptor_ext(
		&self,
		p_descriptor_info: *const vk::DescriptorGetInfoEXT<'_>,
		data_size: usize,
		p_descriptor: *mut std::ffi::c_void,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_descriptor_ext(self, p_descriptor_info, data_size, p_descriptor) }
	}
}

/// Call `vkCmdBindDescriptorBuffersEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindDescriptorBuffersEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBindDescriptorBuffersEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdBindDescriptorBuffersEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindDescriptorBuffersEXT.html)"]
pub unsafe fn cmd_bind_descriptor_buffers_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	buffer_count: u32,
	p_binding_infos: *const vk::DescriptorBufferBindingInfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_descriptor_buffers_ext
		.ok_or(CallError::MissingCommand("vkCmdBindDescriptorBuffersEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, buffer_count, p_binding_infos) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBindDescriptorBuffersEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindDescriptorBuffersEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBindDescriptorBuffersEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindDescriptorBuffersEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindDescriptorBuffersEXT.html)"]
	#[inline]
	pub unsafe fn cmd_bind_descriptor_buffers_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		buffer_count: u32,
		p_binding_infos: *const vk::DescriptorBufferBindingInfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_bind_descriptor_buffers_ext(self, command_buffer, buffer_count, p_binding_infos) }
	}
}

/// Call `vkCmdSetDescriptorBufferOffsetsEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDescriptorBufferOffsetsEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDescriptorBufferOffsetsEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDescriptorBufferOffsetsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDescriptorBufferOffsetsEXT.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_set_descriptor_buffer_offsets_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	pipeline_bind_point: vk::PipelineBindPoint,
	layout: vk::PipelineLayout,
	first_set: u32,
	set_count: u32,
	p_buffer_indices: *const u32,
	p_offsets: *const vk::DeviceSize,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_descriptor_buffer_offsets_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdSetDescriptorBufferOffsetsEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			pipeline_bind_point,
			layout,
			first_set,
			set_count,
			p_buffer_indices,
			p_offsets,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDescriptorBufferOffsetsEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDescriptorBufferOffsetsEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDescriptorBufferOffsetsEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDescriptorBufferOffsetsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDescriptorBufferOffsetsEXT.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_set_descriptor_buffer_offsets_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		pipeline_bind_point: vk::PipelineBindPoint,
		layout: vk::PipelineLayout,
		first_set: u32,
		set_count: u32,
		p_buffer_indices: *const u32,
		p_offsets: *const vk::DeviceSize,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_descriptor_buffer_offsets_ext(
				self,
				command_buffer,
				pipeline_bind_point,
				layout,
				first_set,
				set_count,
				p_buffer_indices,
				p_offsets,
			)
		}
	}
}

/// Call `vkCmdBindDescriptorBufferEmbeddedSamplersEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindDescriptorBufferEmbeddedSamplersEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBindDescriptorBufferEmbeddedSamplersEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdBindDescriptorBufferEmbeddedSamplersEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindDescriptorBufferEmbeddedSamplersEXT.html)"]
pub unsafe fn cmd_bind_descriptor_buffer_embedded_samplers_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	pipeline_bind_point: vk::PipelineBindPoint,
	layout: vk::PipelineLayout,
	set: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_descriptor_buffer_embedded_samplers_ext
		.ok_or(CallError::MissingCommand(
			"vkCmdBindDescriptorBufferEmbeddedSamplersEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, pipeline_bind_point, layout, set) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBindDescriptorBufferEmbeddedSamplersEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindDescriptorBufferEmbeddedSamplersEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBindDescriptorBufferEmbeddedSamplersEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindDescriptorBufferEmbeddedSamplersEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindDescriptorBufferEmbeddedSamplersEXT.html)"]
	#[inline]
	pub unsafe fn cmd_bind_descriptor_buffer_embedded_samplers_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		pipeline_bind_point: vk::PipelineBindPoint,
		layout: vk::PipelineLayout,
		set: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_bind_descriptor_buffer_embedded_samplers_ext(
				self,
				command_buffer,
				pipeline_bind_point,
				layout,
				set,
			)
		}
	}
}

/// Call `vkGetBufferOpaqueCaptureDescriptorDataEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetBufferOpaqueCaptureDescriptorDataEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetBufferOpaqueCaptureDescriptorDataEXT")]
#[doc = "\n\n[Khronos reference: `vkGetBufferOpaqueCaptureDescriptorDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetBufferOpaqueCaptureDescriptorDataEXT.html)"]
pub unsafe fn get_buffer_opaque_capture_descriptor_data_ext(
	device: &Device,
	p_info: *const vk::BufferCaptureDescriptorDataInfoEXT<'_>,
	p_data: *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_buffer_opaque_capture_descriptor_data_ext
		.ok_or(CallError::MissingCommand(
			"vkGetBufferOpaqueCaptureDescriptorDataEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_info, p_data) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetBufferOpaqueCaptureDescriptorDataEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetBufferOpaqueCaptureDescriptorDataEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetBufferOpaqueCaptureDescriptorDataEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetBufferOpaqueCaptureDescriptorDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetBufferOpaqueCaptureDescriptorDataEXT.html)"]
	#[inline]
	pub unsafe fn get_buffer_opaque_capture_descriptor_data_ext(
		&self,
		p_info: *const vk::BufferCaptureDescriptorDataInfoEXT<'_>,
		p_data: *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_buffer_opaque_capture_descriptor_data_ext(self, p_info, p_data) }
	}
}

/// Call `vkGetImageOpaqueCaptureDescriptorDataEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetImageOpaqueCaptureDescriptorDataEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetImageOpaqueCaptureDescriptorDataEXT")]
#[doc = "\n\n[Khronos reference: `vkGetImageOpaqueCaptureDescriptorDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageOpaqueCaptureDescriptorDataEXT.html)"]
pub unsafe fn get_image_opaque_capture_descriptor_data_ext(
	device: &Device,
	p_info: *const vk::ImageCaptureDescriptorDataInfoEXT<'_>,
	p_data: *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_image_opaque_capture_descriptor_data_ext
		.ok_or(CallError::MissingCommand(
			"vkGetImageOpaqueCaptureDescriptorDataEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_info, p_data) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetImageOpaqueCaptureDescriptorDataEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetImageOpaqueCaptureDescriptorDataEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetImageOpaqueCaptureDescriptorDataEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetImageOpaqueCaptureDescriptorDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageOpaqueCaptureDescriptorDataEXT.html)"]
	#[inline]
	pub unsafe fn get_image_opaque_capture_descriptor_data_ext(
		&self,
		p_info: *const vk::ImageCaptureDescriptorDataInfoEXT<'_>,
		p_data: *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_image_opaque_capture_descriptor_data_ext(self, p_info, p_data) }
	}
}

/// Call `vkGetImageViewOpaqueCaptureDescriptorDataEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetImageViewOpaqueCaptureDescriptorDataEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetImageViewOpaqueCaptureDescriptorDataEXT")]
#[doc = "\n\n[Khronos reference: `vkGetImageViewOpaqueCaptureDescriptorDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html)"]
pub unsafe fn get_image_view_opaque_capture_descriptor_data_ext(
	device: &Device,
	p_info: *const vk::ImageViewCaptureDescriptorDataInfoEXT<'_>,
	p_data: *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_image_view_opaque_capture_descriptor_data_ext
		.ok_or(CallError::MissingCommand(
			"vkGetImageViewOpaqueCaptureDescriptorDataEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_info, p_data) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetImageViewOpaqueCaptureDescriptorDataEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetImageViewOpaqueCaptureDescriptorDataEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetImageViewOpaqueCaptureDescriptorDataEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetImageViewOpaqueCaptureDescriptorDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html)"]
	#[inline]
	pub unsafe fn get_image_view_opaque_capture_descriptor_data_ext(
		&self,
		p_info: *const vk::ImageViewCaptureDescriptorDataInfoEXT<'_>,
		p_data: *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_image_view_opaque_capture_descriptor_data_ext(self, p_info, p_data) }
	}
}

/// Call `vkGetSamplerOpaqueCaptureDescriptorDataEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetSamplerOpaqueCaptureDescriptorDataEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetSamplerOpaqueCaptureDescriptorDataEXT")]
#[doc = "\n\n[Khronos reference: `vkGetSamplerOpaqueCaptureDescriptorDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html)"]
pub unsafe fn get_sampler_opaque_capture_descriptor_data_ext(
	device: &Device,
	p_info: *const vk::SamplerCaptureDescriptorDataInfoEXT<'_>,
	p_data: *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_sampler_opaque_capture_descriptor_data_ext
		.ok_or(CallError::MissingCommand(
			"vkGetSamplerOpaqueCaptureDescriptorDataEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_info, p_data) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetSamplerOpaqueCaptureDescriptorDataEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetSamplerOpaqueCaptureDescriptorDataEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetSamplerOpaqueCaptureDescriptorDataEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetSamplerOpaqueCaptureDescriptorDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html)"]
	#[inline]
	pub unsafe fn get_sampler_opaque_capture_descriptor_data_ext(
		&self,
		p_info: *const vk::SamplerCaptureDescriptorDataInfoEXT<'_>,
		p_data: *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_sampler_opaque_capture_descriptor_data_ext(self, p_info, p_data) }
	}
}

/// Call `vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT")]
#[doc = "\n\n[Khronos reference: `vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html)"]
pub unsafe fn get_acceleration_structure_opaque_capture_descriptor_data_ext(
	device: &Device,
	p_info: *const vk::AccelerationStructureCaptureDescriptorDataInfoEXT<'_>,
	p_data: *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_acceleration_structure_opaque_capture_descriptor_data_ext
		.ok_or(CallError::MissingCommand(
			"vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_info, p_data) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html)"]
	#[inline]
	pub unsafe fn get_acceleration_structure_opaque_capture_descriptor_data_ext(
		&self,
		p_info: *const vk::AccelerationStructureCaptureDescriptorDataInfoEXT<'_>,
		p_data: *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_acceleration_structure_opaque_capture_descriptor_data_ext(self, p_info, p_data) }
	}
}

/// Call `vkSetDeviceMemoryPriorityEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkSetDeviceMemoryPriorityEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkSetDeviceMemoryPriorityEXT")]
#[doc = "\n\n[Khronos reference: `vkSetDeviceMemoryPriorityEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetDeviceMemoryPriorityEXT.html)"]
pub unsafe fn set_device_memory_priority_ext(
	device: &Device,
	memory: vk::DeviceMemory,
	priority: f32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.set_device_memory_priority_ext
		.ok_or(CallError::MissingCommand("vkSetDeviceMemoryPriorityEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), memory, priority) };
	Ok(())
}

impl Device {
	/// Call `vkSetDeviceMemoryPriorityEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkSetDeviceMemoryPriorityEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkSetDeviceMemoryPriorityEXT")]
	#[doc = "\n\n[Khronos reference: `vkSetDeviceMemoryPriorityEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetDeviceMemoryPriorityEXT.html)"]
	#[inline]
	pub unsafe fn set_device_memory_priority_ext(
		&self,
		memory: vk::DeviceMemory,
		priority: f32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { set_device_memory_priority_ext(self, memory, priority) }
	}
}

/// Call `vkAcquireDrmDisplayEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkAcquireDrmDisplayEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkAcquireDrmDisplayEXT")]
#[doc = "\n\n[Khronos reference: `vkAcquireDrmDisplayEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkAcquireDrmDisplayEXT.html)"]
pub unsafe fn acquire_drm_display_ext(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	drm_fd: i32,
	display: vk::DisplayKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.acquire_drm_display_ext
		.ok_or(CallError::MissingCommand("vkAcquireDrmDisplayEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, drm_fd, display) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkAcquireDrmDisplayEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkAcquireDrmDisplayEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkAcquireDrmDisplayEXT")]
	#[doc = "\n\n[Khronos reference: `vkAcquireDrmDisplayEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkAcquireDrmDisplayEXT.html)"]
	#[inline]
	pub unsafe fn acquire_drm_display_ext(
		&self,
		physical_device: vk::PhysicalDevice,
		drm_fd: i32,
		display: vk::DisplayKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { acquire_drm_display_ext(self, physical_device, drm_fd, display) }
	}
}

/// Call `vkGetDrmDisplayEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDrmDisplayEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDrmDisplayEXT")]
#[doc = "\n\n[Khronos reference: `vkGetDrmDisplayEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDrmDisplayEXT.html)"]
pub unsafe fn get_drm_display_ext(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	drm_fd: i32,
	connector_id: u32,
	display: *mut vk::DisplayKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_drm_display_ext
		.ok_or(CallError::MissingCommand("vkGetDrmDisplayEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, drm_fd, connector_id, display) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetDrmDisplayEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDrmDisplayEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDrmDisplayEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetDrmDisplayEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDrmDisplayEXT.html)"]
	#[inline]
	pub unsafe fn get_drm_display_ext(
		&self,
		physical_device: vk::PhysicalDevice,
		drm_fd: i32,
		connector_id: u32,
		display: *mut vk::DisplayKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_drm_display_ext(self, physical_device, drm_fd, connector_id, display) }
	}
}

/// Call `vkWaitForPresent2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkWaitForPresent2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkWaitForPresent2KHR")]
#[doc = "\n\n[Khronos reference: `vkWaitForPresent2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkWaitForPresent2KHR.html)"]
pub unsafe fn wait_for_present2_khr(
	device: &Device,
	swapchain: vk::SwapchainKHR,
	p_present_wait2_info: *const vk::PresentWait2InfoKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.wait_for_present2_khr
		.ok_or(CallError::MissingCommand("vkWaitForPresent2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), swapchain, p_present_wait2_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkWaitForPresent2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkWaitForPresent2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkWaitForPresent2KHR")]
	#[doc = "\n\n[Khronos reference: `vkWaitForPresent2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkWaitForPresent2KHR.html)"]
	#[inline]
	pub unsafe fn wait_for_present2_khr(
		&self,
		swapchain: vk::SwapchainKHR,
		p_present_wait2_info: *const vk::PresentWait2InfoKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { wait_for_present2_khr(self, swapchain, p_present_wait2_info) }
	}
}

/// Call `vkWaitForPresentKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkWaitForPresentKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkWaitForPresentKHR")]
#[doc = "\n\n[Khronos reference: `vkWaitForPresentKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkWaitForPresentKHR.html)"]
pub unsafe fn wait_for_present_khr(
	device: &Device,
	swapchain: vk::SwapchainKHR,
	present_id: u64,
	timeout: u64,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.wait_for_present_khr
		.ok_or(CallError::MissingCommand("vkWaitForPresentKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), swapchain, present_id, timeout) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkWaitForPresentKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkWaitForPresentKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkWaitForPresentKHR")]
	#[doc = "\n\n[Khronos reference: `vkWaitForPresentKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkWaitForPresentKHR.html)"]
	#[inline]
	pub unsafe fn wait_for_present_khr(
		&self,
		swapchain: vk::SwapchainKHR,
		present_id: u64,
		timeout: u64,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { wait_for_present_khr(self, swapchain, present_id, timeout) }
	}
}

#[cfg(feature = "platform-fuchsia")]
/// Call `vkCreateBufferCollectionFUCHSIA` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateBufferCollectionFUCHSIA` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateBufferCollectionFUCHSIA")]
#[doc = "\n\n[Khronos reference: `vkCreateBufferCollectionFUCHSIA`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateBufferCollectionFUCHSIA.html)"]
pub unsafe fn create_buffer_collection_fuchsia(
	device: &Device,
	p_create_info: *const vk::BufferCollectionCreateInfoFUCHSIA<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_collection: *mut vk::BufferCollectionFUCHSIA,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_buffer_collection_fuchsia
		.ok_or(CallError::MissingCommand("vkCreateBufferCollectionFUCHSIA"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_create_info, p_allocator, p_collection) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-fuchsia")]
impl Device {
	/// Call `vkCreateBufferCollectionFUCHSIA` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateBufferCollectionFUCHSIA` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateBufferCollectionFUCHSIA")]
	#[doc = "\n\n[Khronos reference: `vkCreateBufferCollectionFUCHSIA`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateBufferCollectionFUCHSIA.html)"]
	#[inline]
	pub unsafe fn create_buffer_collection_fuchsia(
		&self,
		p_create_info: *const vk::BufferCollectionCreateInfoFUCHSIA<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_collection: *mut vk::BufferCollectionFUCHSIA,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_buffer_collection_fuchsia(self, p_create_info, p_allocator, p_collection) }
	}
}

#[cfg(feature = "platform-fuchsia")]
/// Call `vkSetBufferCollectionBufferConstraintsFUCHSIA` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkSetBufferCollectionBufferConstraintsFUCHSIA` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkSetBufferCollectionBufferConstraintsFUCHSIA")]
#[doc = "\n\n[Khronos reference: `vkSetBufferCollectionBufferConstraintsFUCHSIA`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetBufferCollectionBufferConstraintsFUCHSIA.html)"]
pub unsafe fn set_buffer_collection_buffer_constraints_fuchsia(
	device: &Device,
	collection: vk::BufferCollectionFUCHSIA,
	p_buffer_constraints_info: *const vk::BufferConstraintsInfoFUCHSIA<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.set_buffer_collection_buffer_constraints_fuchsia
		.ok_or(CallError::MissingCommand(
			"vkSetBufferCollectionBufferConstraintsFUCHSIA",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), collection, p_buffer_constraints_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-fuchsia")]
impl Device {
	/// Call `vkSetBufferCollectionBufferConstraintsFUCHSIA` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkSetBufferCollectionBufferConstraintsFUCHSIA` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkSetBufferCollectionBufferConstraintsFUCHSIA")]
	#[doc = "\n\n[Khronos reference: `vkSetBufferCollectionBufferConstraintsFUCHSIA`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetBufferCollectionBufferConstraintsFUCHSIA.html)"]
	#[inline]
	pub unsafe fn set_buffer_collection_buffer_constraints_fuchsia(
		&self,
		collection: vk::BufferCollectionFUCHSIA,
		p_buffer_constraints_info: *const vk::BufferConstraintsInfoFUCHSIA<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			set_buffer_collection_buffer_constraints_fuchsia(self, collection, p_buffer_constraints_info)
		}
	}
}

#[cfg(feature = "platform-fuchsia")]
/// Call `vkSetBufferCollectionImageConstraintsFUCHSIA` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkSetBufferCollectionImageConstraintsFUCHSIA` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkSetBufferCollectionImageConstraintsFUCHSIA")]
#[doc = "\n\n[Khronos reference: `vkSetBufferCollectionImageConstraintsFUCHSIA`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetBufferCollectionImageConstraintsFUCHSIA.html)"]
pub unsafe fn set_buffer_collection_image_constraints_fuchsia(
	device: &Device,
	collection: vk::BufferCollectionFUCHSIA,
	p_image_constraints_info: *const vk::ImageConstraintsInfoFUCHSIA<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.set_buffer_collection_image_constraints_fuchsia
		.ok_or(CallError::MissingCommand(
			"vkSetBufferCollectionImageConstraintsFUCHSIA",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), collection, p_image_constraints_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-fuchsia")]
impl Device {
	/// Call `vkSetBufferCollectionImageConstraintsFUCHSIA` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkSetBufferCollectionImageConstraintsFUCHSIA` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkSetBufferCollectionImageConstraintsFUCHSIA")]
	#[doc = "\n\n[Khronos reference: `vkSetBufferCollectionImageConstraintsFUCHSIA`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetBufferCollectionImageConstraintsFUCHSIA.html)"]
	#[inline]
	pub unsafe fn set_buffer_collection_image_constraints_fuchsia(
		&self,
		collection: vk::BufferCollectionFUCHSIA,
		p_image_constraints_info: *const vk::ImageConstraintsInfoFUCHSIA<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			set_buffer_collection_image_constraints_fuchsia(self, collection, p_image_constraints_info)
		}
	}
}

#[cfg(feature = "platform-fuchsia")]
/// Call `vkDestroyBufferCollectionFUCHSIA` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyBufferCollectionFUCHSIA` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyBufferCollectionFUCHSIA")]
#[doc = "\n\n[Khronos reference: `vkDestroyBufferCollectionFUCHSIA`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyBufferCollectionFUCHSIA.html)"]
pub unsafe fn destroy_buffer_collection_fuchsia(
	device: &Device,
	collection: vk::BufferCollectionFUCHSIA,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.destroy_buffer_collection_fuchsia
			.ok_or(CallError::MissingCommand(
				"vkDestroyBufferCollectionFUCHSIA",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), collection, p_allocator) };
	Ok(())
}

#[cfg(feature = "platform-fuchsia")]
impl Device {
	/// Call `vkDestroyBufferCollectionFUCHSIA` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyBufferCollectionFUCHSIA` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyBufferCollectionFUCHSIA")]
	#[doc = "\n\n[Khronos reference: `vkDestroyBufferCollectionFUCHSIA`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyBufferCollectionFUCHSIA.html)"]
	#[inline]
	pub unsafe fn destroy_buffer_collection_fuchsia(
		&self,
		collection: vk::BufferCollectionFUCHSIA,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_buffer_collection_fuchsia(self, collection, p_allocator) }
	}
}

#[cfg(feature = "platform-fuchsia")]
/// Call `vkGetBufferCollectionPropertiesFUCHSIA` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetBufferCollectionPropertiesFUCHSIA` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetBufferCollectionPropertiesFUCHSIA")]
#[doc = "\n\n[Khronos reference: `vkGetBufferCollectionPropertiesFUCHSIA`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetBufferCollectionPropertiesFUCHSIA.html)"]
pub unsafe fn get_buffer_collection_properties_fuchsia(
	device: &Device,
	collection: vk::BufferCollectionFUCHSIA,
	p_properties: *mut vk::BufferCollectionPropertiesFUCHSIA<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.get_buffer_collection_properties_fuchsia
			.ok_or(CallError::MissingCommand(
				"vkGetBufferCollectionPropertiesFUCHSIA",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), collection, p_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-fuchsia")]
impl Device {
	/// Call `vkGetBufferCollectionPropertiesFUCHSIA` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetBufferCollectionPropertiesFUCHSIA` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetBufferCollectionPropertiesFUCHSIA")]
	#[doc = "\n\n[Khronos reference: `vkGetBufferCollectionPropertiesFUCHSIA`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetBufferCollectionPropertiesFUCHSIA.html)"]
	#[inline]
	pub unsafe fn get_buffer_collection_properties_fuchsia(
		&self,
		collection: vk::BufferCollectionFUCHSIA,
		p_properties: *mut vk::BufferCollectionPropertiesFUCHSIA<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_buffer_collection_properties_fuchsia(self, collection, p_properties) }
	}
}

#[cfg(feature = "provisional")]
/// Call `vkCreateCudaModuleNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateCudaModuleNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateCudaModuleNV")]
#[doc = "\n\n[Khronos reference: `vkCreateCudaModuleNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateCudaModuleNV.html)"]
pub unsafe fn create_cuda_module_nv(
	device: &Device,
	p_create_info: *const vk::CudaModuleCreateInfoNV<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_module: *mut vk::CudaModuleNV,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_cuda_module_nv
		.ok_or(CallError::MissingCommand("vkCreateCudaModuleNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_create_info, p_allocator, p_module) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "provisional")]
impl Device {
	/// Call `vkCreateCudaModuleNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateCudaModuleNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateCudaModuleNV")]
	#[doc = "\n\n[Khronos reference: `vkCreateCudaModuleNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateCudaModuleNV.html)"]
	#[inline]
	pub unsafe fn create_cuda_module_nv(
		&self,
		p_create_info: *const vk::CudaModuleCreateInfoNV<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_module: *mut vk::CudaModuleNV,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_cuda_module_nv(self, p_create_info, p_allocator, p_module) }
	}
}

#[cfg(feature = "provisional")]
/// Call `vkGetCudaModuleCacheNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetCudaModuleCacheNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetCudaModuleCacheNV")]
#[doc = "\n\n[Khronos reference: `vkGetCudaModuleCacheNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetCudaModuleCacheNV.html)"]
pub unsafe fn get_cuda_module_cache_nv(
	device: &Device,
	module: vk::CudaModuleNV,
	p_cache_size: *mut usize,
	p_cache_data: *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_cuda_module_cache_nv
		.ok_or(CallError::MissingCommand("vkGetCudaModuleCacheNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), module, p_cache_size, p_cache_data) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "provisional")]
impl Device {
	/// Call `vkGetCudaModuleCacheNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetCudaModuleCacheNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetCudaModuleCacheNV")]
	#[doc = "\n\n[Khronos reference: `vkGetCudaModuleCacheNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetCudaModuleCacheNV.html)"]
	#[inline]
	pub unsafe fn get_cuda_module_cache_nv(
		&self,
		module: vk::CudaModuleNV,
		p_cache_size: *mut usize,
		p_cache_data: *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_cuda_module_cache_nv(self, module, p_cache_size, p_cache_data) }
	}
}

#[cfg(feature = "provisional")]
/// Call `vkCreateCudaFunctionNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateCudaFunctionNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateCudaFunctionNV")]
#[doc = "\n\n[Khronos reference: `vkCreateCudaFunctionNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateCudaFunctionNV.html)"]
pub unsafe fn create_cuda_function_nv(
	device: &Device,
	p_create_info: *const vk::CudaFunctionCreateInfoNV<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_function: *mut vk::CudaFunctionNV,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_cuda_function_nv
		.ok_or(CallError::MissingCommand("vkCreateCudaFunctionNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_create_info, p_allocator, p_function) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "provisional")]
impl Device {
	/// Call `vkCreateCudaFunctionNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateCudaFunctionNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateCudaFunctionNV")]
	#[doc = "\n\n[Khronos reference: `vkCreateCudaFunctionNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateCudaFunctionNV.html)"]
	#[inline]
	pub unsafe fn create_cuda_function_nv(
		&self,
		p_create_info: *const vk::CudaFunctionCreateInfoNV<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_function: *mut vk::CudaFunctionNV,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_cuda_function_nv(self, p_create_info, p_allocator, p_function) }
	}
}

#[cfg(feature = "provisional")]
/// Call `vkDestroyCudaModuleNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyCudaModuleNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyCudaModuleNV")]
#[doc = "\n\n[Khronos reference: `vkDestroyCudaModuleNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyCudaModuleNV.html)"]
pub unsafe fn destroy_cuda_module_nv(
	device: &Device,
	module: vk::CudaModuleNV,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_cuda_module_nv
		.ok_or(CallError::MissingCommand("vkDestroyCudaModuleNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), module, p_allocator) };
	Ok(())
}

#[cfg(feature = "provisional")]
impl Device {
	/// Call `vkDestroyCudaModuleNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyCudaModuleNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyCudaModuleNV")]
	#[doc = "\n\n[Khronos reference: `vkDestroyCudaModuleNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyCudaModuleNV.html)"]
	#[inline]
	pub unsafe fn destroy_cuda_module_nv(
		&self,
		module: vk::CudaModuleNV,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_cuda_module_nv(self, module, p_allocator) }
	}
}

#[cfg(feature = "provisional")]
/// Call `vkDestroyCudaFunctionNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyCudaFunctionNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyCudaFunctionNV")]
#[doc = "\n\n[Khronos reference: `vkDestroyCudaFunctionNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyCudaFunctionNV.html)"]
pub unsafe fn destroy_cuda_function_nv(
	device: &Device,
	function: vk::CudaFunctionNV,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_cuda_function_nv
		.ok_or(CallError::MissingCommand("vkDestroyCudaFunctionNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), function, p_allocator) };
	Ok(())
}

#[cfg(feature = "provisional")]
impl Device {
	/// Call `vkDestroyCudaFunctionNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyCudaFunctionNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyCudaFunctionNV")]
	#[doc = "\n\n[Khronos reference: `vkDestroyCudaFunctionNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyCudaFunctionNV.html)"]
	#[inline]
	pub unsafe fn destroy_cuda_function_nv(
		&self,
		function: vk::CudaFunctionNV,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_cuda_function_nv(self, function, p_allocator) }
	}
}

#[cfg(feature = "provisional")]
/// Call `vkCmdCudaLaunchKernelNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCudaLaunchKernelNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdCudaLaunchKernelNV")]
#[doc = "\n\n[Khronos reference: `vkCmdCudaLaunchKernelNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCudaLaunchKernelNV.html)"]
pub unsafe fn cmd_cuda_launch_kernel_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_launch_info: *const vk::CudaLaunchInfoNV<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_cuda_launch_kernel_nv
		.ok_or(CallError::MissingCommand("vkCmdCudaLaunchKernelNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_launch_info) };
	Ok(())
}

#[cfg(feature = "provisional")]
impl Device {
	/// Call `vkCmdCudaLaunchKernelNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCudaLaunchKernelNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdCudaLaunchKernelNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdCudaLaunchKernelNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCudaLaunchKernelNV.html)"]
	#[inline]
	pub unsafe fn cmd_cuda_launch_kernel_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		p_launch_info: *const vk::CudaLaunchInfoNV<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_cuda_launch_kernel_nv(self, command_buffer, p_launch_info) }
	}
}

/// Call `vkCmdBeginRendering` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBeginRendering` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBeginRendering")]
#[doc = "\n\n[Khronos reference: `vkCmdBeginRendering`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginRendering.html)"]
pub unsafe fn cmd_begin_rendering(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_rendering_info: *const vk::RenderingInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_begin_rendering
		.ok_or(CallError::MissingCommand("vkCmdBeginRendering"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_rendering_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBeginRendering` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBeginRendering` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBeginRendering")]
	#[doc = "\n\n[Khronos reference: `vkCmdBeginRendering`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginRendering.html)"]
	#[inline]
	pub unsafe fn cmd_begin_rendering(
		&self,
		command_buffer: vk::CommandBuffer,
		p_rendering_info: *const vk::RenderingInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_begin_rendering(self, command_buffer, p_rendering_info) }
	}
}

/// Call `vkCmdBeginRenderingKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBeginRenderingKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBeginRenderingKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdBeginRenderingKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginRenderingKHR.html)"]
pub unsafe fn cmd_begin_rendering_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_rendering_info: *const vk::RenderingInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_begin_rendering_khr
		.ok_or(CallError::MissingCommand("vkCmdBeginRenderingKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_rendering_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBeginRenderingKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBeginRenderingKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBeginRenderingKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdBeginRenderingKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginRenderingKHR.html)"]
	#[inline]
	pub unsafe fn cmd_begin_rendering_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_rendering_info: *const vk::RenderingInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_begin_rendering_khr(self, command_buffer, p_rendering_info) }
	}
}

/// Call `vkCmdEndRendering` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdEndRendering` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdEndRendering")]
#[doc = "\n\n[Khronos reference: `vkCmdEndRendering`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndRendering.html)"]
pub unsafe fn cmd_end_rendering(
	device: &Device,
	command_buffer: vk::CommandBuffer,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_end_rendering
		.ok_or(CallError::MissingCommand("vkCmdEndRendering"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer) };
	Ok(())
}

impl Device {
	/// Call `vkCmdEndRendering` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdEndRendering` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdEndRendering")]
	#[doc = "\n\n[Khronos reference: `vkCmdEndRendering`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndRendering.html)"]
	#[inline]
	pub unsafe fn cmd_end_rendering(
		&self,
		command_buffer: vk::CommandBuffer,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_end_rendering(self, command_buffer) }
	}
}

/// Call `vkCmdEndRendering2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdEndRendering2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdEndRendering2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdEndRendering2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndRendering2KHR.html)"]
pub unsafe fn cmd_end_rendering2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_rendering_end_info: *const vk::RenderingEndInfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_end_rendering2_khr
		.ok_or(CallError::MissingCommand("vkCmdEndRendering2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_rendering_end_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdEndRendering2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdEndRendering2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdEndRendering2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdEndRendering2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndRendering2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_end_rendering2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_rendering_end_info: *const vk::RenderingEndInfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_end_rendering2_khr(self, command_buffer, p_rendering_end_info) }
	}
}

/// Call `vkCmdEndRendering2EXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdEndRendering2EXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdEndRendering2EXT")]
#[doc = "\n\n[Khronos reference: `vkCmdEndRendering2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndRendering2EXT.html)"]
pub unsafe fn cmd_end_rendering2_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_rendering_end_info: *const vk::RenderingEndInfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_end_rendering2_ext
		.ok_or(CallError::MissingCommand("vkCmdEndRendering2EXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_rendering_end_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdEndRendering2EXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdEndRendering2EXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdEndRendering2EXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdEndRendering2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndRendering2EXT.html)"]
	#[inline]
	pub unsafe fn cmd_end_rendering2_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_rendering_end_info: *const vk::RenderingEndInfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_end_rendering2_ext(self, command_buffer, p_rendering_end_info) }
	}
}

/// Call `vkCmdEndRenderingKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdEndRenderingKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdEndRenderingKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdEndRenderingKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndRenderingKHR.html)"]
pub unsafe fn cmd_end_rendering_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_end_rendering_khr
		.ok_or(CallError::MissingCommand("vkCmdEndRenderingKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer) };
	Ok(())
}

impl Device {
	/// Call `vkCmdEndRenderingKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdEndRenderingKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdEndRenderingKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdEndRenderingKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndRenderingKHR.html)"]
	#[inline]
	pub unsafe fn cmd_end_rendering_khr(
		&self,
		command_buffer: vk::CommandBuffer,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_end_rendering_khr(self, command_buffer) }
	}
}

/// Call `vkGetDescriptorSetLayoutHostMappingInfoVALVE` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDescriptorSetLayoutHostMappingInfoVALVE` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDescriptorSetLayoutHostMappingInfoVALVE")]
#[doc = "\n\n[Khronos reference: `vkGetDescriptorSetLayoutHostMappingInfoVALVE`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html)"]
pub unsafe fn get_descriptor_set_layout_host_mapping_info_valve(
	device: &Device,
	p_binding_reference: *const vk::DescriptorSetBindingReferenceVALVE<'_>,
	p_host_mapping: *mut vk::DescriptorSetLayoutHostMappingInfoVALVE<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_descriptor_set_layout_host_mapping_info_valve
		.ok_or(CallError::MissingCommand(
			"vkGetDescriptorSetLayoutHostMappingInfoVALVE",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_binding_reference, p_host_mapping) };
	Ok(())
}

impl Device {
	/// Call `vkGetDescriptorSetLayoutHostMappingInfoVALVE` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDescriptorSetLayoutHostMappingInfoVALVE` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDescriptorSetLayoutHostMappingInfoVALVE")]
	#[doc = "\n\n[Khronos reference: `vkGetDescriptorSetLayoutHostMappingInfoVALVE`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html)"]
	#[inline]
	pub unsafe fn get_descriptor_set_layout_host_mapping_info_valve(
		&self,
		p_binding_reference: *const vk::DescriptorSetBindingReferenceVALVE<'_>,
		p_host_mapping: *mut vk::DescriptorSetLayoutHostMappingInfoVALVE<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_descriptor_set_layout_host_mapping_info_valve(self, p_binding_reference, p_host_mapping)
		}
	}
}

/// Call `vkGetDescriptorSetHostMappingVALVE` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDescriptorSetHostMappingVALVE` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDescriptorSetHostMappingVALVE")]
#[doc = "\n\n[Khronos reference: `vkGetDescriptorSetHostMappingVALVE`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDescriptorSetHostMappingVALVE.html)"]
pub unsafe fn get_descriptor_set_host_mapping_valve(
	device: &Device,
	descriptor_set: vk::DescriptorSet,
	pp_data: *mut *mut std::ffi::c_void,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.get_descriptor_set_host_mapping_valve
			.ok_or(CallError::MissingCommand(
				"vkGetDescriptorSetHostMappingVALVE",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), descriptor_set, pp_data) };
	Ok(())
}

impl Device {
	/// Call `vkGetDescriptorSetHostMappingVALVE` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDescriptorSetHostMappingVALVE` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDescriptorSetHostMappingVALVE")]
	#[doc = "\n\n[Khronos reference: `vkGetDescriptorSetHostMappingVALVE`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDescriptorSetHostMappingVALVE.html)"]
	#[inline]
	pub unsafe fn get_descriptor_set_host_mapping_valve(
		&self,
		descriptor_set: vk::DescriptorSet,
		pp_data: *mut *mut std::ffi::c_void,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_descriptor_set_host_mapping_valve(self, descriptor_set, pp_data) }
	}
}

/// Call `vkCreateMicromapEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateMicromapEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateMicromapEXT")]
#[doc = "\n\n[Khronos reference: `vkCreateMicromapEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateMicromapEXT.html)"]
pub unsafe fn create_micromap_ext(
	device: &Device,
	p_create_info: *const vk::MicromapCreateInfoEXT<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_micromap: *mut vk::MicromapEXT,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_micromap_ext
		.ok_or(CallError::MissingCommand("vkCreateMicromapEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_create_info, p_allocator, p_micromap) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateMicromapEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateMicromapEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateMicromapEXT")]
	#[doc = "\n\n[Khronos reference: `vkCreateMicromapEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateMicromapEXT.html)"]
	#[inline]
	pub unsafe fn create_micromap_ext(
		&self,
		p_create_info: *const vk::MicromapCreateInfoEXT<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_micromap: *mut vk::MicromapEXT,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_micromap_ext(self, p_create_info, p_allocator, p_micromap) }
	}
}

/// Call `vkCmdBuildMicromapsEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBuildMicromapsEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBuildMicromapsEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdBuildMicromapsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBuildMicromapsEXT.html)"]
pub unsafe fn cmd_build_micromaps_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	info_count: u32,
	p_infos: *const vk::MicromapBuildInfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_build_micromaps_ext
		.ok_or(CallError::MissingCommand("vkCmdBuildMicromapsEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, info_count, p_infos) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBuildMicromapsEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBuildMicromapsEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBuildMicromapsEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdBuildMicromapsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBuildMicromapsEXT.html)"]
	#[inline]
	pub unsafe fn cmd_build_micromaps_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		info_count: u32,
		p_infos: *const vk::MicromapBuildInfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_build_micromaps_ext(self, command_buffer, info_count, p_infos) }
	}
}

/// Call `vkBuildMicromapsEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkBuildMicromapsEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkBuildMicromapsEXT")]
#[doc = "\n\n[Khronos reference: `vkBuildMicromapsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBuildMicromapsEXT.html)"]
pub unsafe fn build_micromaps_ext(
	device: &Device,
	deferred_operation: vk::DeferredOperationKHR,
	info_count: u32,
	p_infos: *const vk::MicromapBuildInfoEXT<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.build_micromaps_ext
		.ok_or(CallError::MissingCommand("vkBuildMicromapsEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), deferred_operation, info_count, p_infos) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkBuildMicromapsEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkBuildMicromapsEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkBuildMicromapsEXT")]
	#[doc = "\n\n[Khronos reference: `vkBuildMicromapsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBuildMicromapsEXT.html)"]
	#[inline]
	pub unsafe fn build_micromaps_ext(
		&self,
		deferred_operation: vk::DeferredOperationKHR,
		info_count: u32,
		p_infos: *const vk::MicromapBuildInfoEXT<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { build_micromaps_ext(self, deferred_operation, info_count, p_infos) }
	}
}

/// Call `vkDestroyMicromapEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyMicromapEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyMicromapEXT")]
#[doc = "\n\n[Khronos reference: `vkDestroyMicromapEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyMicromapEXT.html)"]
pub unsafe fn destroy_micromap_ext(
	device: &Device,
	micromap: vk::MicromapEXT,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_micromap_ext
		.ok_or(CallError::MissingCommand("vkDestroyMicromapEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), micromap, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyMicromapEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyMicromapEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyMicromapEXT")]
	#[doc = "\n\n[Khronos reference: `vkDestroyMicromapEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyMicromapEXT.html)"]
	#[inline]
	pub unsafe fn destroy_micromap_ext(
		&self,
		micromap: vk::MicromapEXT,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_micromap_ext(self, micromap, p_allocator) }
	}
}

/// Call `vkCmdCopyMicromapEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyMicromapEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdCopyMicromapEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyMicromapEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyMicromapEXT.html)"]
pub unsafe fn cmd_copy_micromap_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_info: *const vk::CopyMicromapInfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_micromap_ext
		.ok_or(CallError::MissingCommand("vkCmdCopyMicromapEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyMicromapEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyMicromapEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdCopyMicromapEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyMicromapEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyMicromapEXT.html)"]
	#[inline]
	pub unsafe fn cmd_copy_micromap_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_info: *const vk::CopyMicromapInfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_micromap_ext(self, command_buffer, p_info) }
	}
}

/// Call `vkCopyMicromapEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCopyMicromapEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCopyMicromapEXT")]
#[doc = "\n\n[Khronos reference: `vkCopyMicromapEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyMicromapEXT.html)"]
pub unsafe fn copy_micromap_ext(
	device: &Device,
	deferred_operation: vk::DeferredOperationKHR,
	p_info: *const vk::CopyMicromapInfoEXT<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.copy_micromap_ext
		.ok_or(CallError::MissingCommand("vkCopyMicromapEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), deferred_operation, p_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCopyMicromapEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCopyMicromapEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCopyMicromapEXT")]
	#[doc = "\n\n[Khronos reference: `vkCopyMicromapEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyMicromapEXT.html)"]
	#[inline]
	pub unsafe fn copy_micromap_ext(
		&self,
		deferred_operation: vk::DeferredOperationKHR,
		p_info: *const vk::CopyMicromapInfoEXT<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { copy_micromap_ext(self, deferred_operation, p_info) }
	}
}

/// Call `vkCmdCopyMicromapToMemoryEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyMicromapToMemoryEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdCopyMicromapToMemoryEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyMicromapToMemoryEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyMicromapToMemoryEXT.html)"]
pub unsafe fn cmd_copy_micromap_to_memory_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_info: *const vk::CopyMicromapToMemoryInfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_micromap_to_memory_ext
		.ok_or(CallError::MissingCommand("vkCmdCopyMicromapToMemoryEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyMicromapToMemoryEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyMicromapToMemoryEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdCopyMicromapToMemoryEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyMicromapToMemoryEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyMicromapToMemoryEXT.html)"]
	#[inline]
	pub unsafe fn cmd_copy_micromap_to_memory_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_info: *const vk::CopyMicromapToMemoryInfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_micromap_to_memory_ext(self, command_buffer, p_info) }
	}
}

/// Call `vkCopyMicromapToMemoryEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCopyMicromapToMemoryEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCopyMicromapToMemoryEXT")]
#[doc = "\n\n[Khronos reference: `vkCopyMicromapToMemoryEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyMicromapToMemoryEXT.html)"]
pub unsafe fn copy_micromap_to_memory_ext(
	device: &Device,
	deferred_operation: vk::DeferredOperationKHR,
	p_info: *const vk::CopyMicromapToMemoryInfoEXT<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.copy_micromap_to_memory_ext
		.ok_or(CallError::MissingCommand("vkCopyMicromapToMemoryEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), deferred_operation, p_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCopyMicromapToMemoryEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCopyMicromapToMemoryEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCopyMicromapToMemoryEXT")]
	#[doc = "\n\n[Khronos reference: `vkCopyMicromapToMemoryEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyMicromapToMemoryEXT.html)"]
	#[inline]
	pub unsafe fn copy_micromap_to_memory_ext(
		&self,
		deferred_operation: vk::DeferredOperationKHR,
		p_info: *const vk::CopyMicromapToMemoryInfoEXT<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { copy_micromap_to_memory_ext(self, deferred_operation, p_info) }
	}
}

/// Call `vkCmdCopyMemoryToMicromapEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyMemoryToMicromapEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdCopyMemoryToMicromapEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyMemoryToMicromapEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyMemoryToMicromapEXT.html)"]
pub unsafe fn cmd_copy_memory_to_micromap_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_info: *const vk::CopyMemoryToMicromapInfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_memory_to_micromap_ext
		.ok_or(CallError::MissingCommand("vkCmdCopyMemoryToMicromapEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyMemoryToMicromapEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyMemoryToMicromapEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdCopyMemoryToMicromapEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyMemoryToMicromapEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyMemoryToMicromapEXT.html)"]
	#[inline]
	pub unsafe fn cmd_copy_memory_to_micromap_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_info: *const vk::CopyMemoryToMicromapInfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_memory_to_micromap_ext(self, command_buffer, p_info) }
	}
}

/// Call `vkCopyMemoryToMicromapEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCopyMemoryToMicromapEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCopyMemoryToMicromapEXT")]
#[doc = "\n\n[Khronos reference: `vkCopyMemoryToMicromapEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyMemoryToMicromapEXT.html)"]
pub unsafe fn copy_memory_to_micromap_ext(
	device: &Device,
	deferred_operation: vk::DeferredOperationKHR,
	p_info: *const vk::CopyMemoryToMicromapInfoEXT<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.copy_memory_to_micromap_ext
		.ok_or(CallError::MissingCommand("vkCopyMemoryToMicromapEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), deferred_operation, p_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCopyMemoryToMicromapEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCopyMemoryToMicromapEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCopyMemoryToMicromapEXT")]
	#[doc = "\n\n[Khronos reference: `vkCopyMemoryToMicromapEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCopyMemoryToMicromapEXT.html)"]
	#[inline]
	pub unsafe fn copy_memory_to_micromap_ext(
		&self,
		deferred_operation: vk::DeferredOperationKHR,
		p_info: *const vk::CopyMemoryToMicromapInfoEXT<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { copy_memory_to_micromap_ext(self, deferred_operation, p_info) }
	}
}

/// Call `vkCmdWriteMicromapsPropertiesEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdWriteMicromapsPropertiesEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdWriteMicromapsPropertiesEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdWriteMicromapsPropertiesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWriteMicromapsPropertiesEXT.html)"]
pub unsafe fn cmd_write_micromaps_properties_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	micromap_count: u32,
	p_micromaps: *const vk::MicromapEXT,
	query_type: vk::QueryType,
	query_pool: vk::QueryPool,
	first_query: u32,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_write_micromaps_properties_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdWriteMicromapsPropertiesEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			micromap_count,
			p_micromaps,
			query_type,
			query_pool,
			first_query,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdWriteMicromapsPropertiesEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdWriteMicromapsPropertiesEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdWriteMicromapsPropertiesEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdWriteMicromapsPropertiesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWriteMicromapsPropertiesEXT.html)"]
	#[inline]
	pub unsafe fn cmd_write_micromaps_properties_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		micromap_count: u32,
		p_micromaps: *const vk::MicromapEXT,
		query_type: vk::QueryType,
		query_pool: vk::QueryPool,
		first_query: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_write_micromaps_properties_ext(
				self,
				command_buffer,
				micromap_count,
				p_micromaps,
				query_type,
				query_pool,
				first_query,
			)
		}
	}
}

/// Call `vkWriteMicromapsPropertiesEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkWriteMicromapsPropertiesEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkWriteMicromapsPropertiesEXT")]
#[doc = "\n\n[Khronos reference: `vkWriteMicromapsPropertiesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkWriteMicromapsPropertiesEXT.html)"]
pub unsafe fn write_micromaps_properties_ext(
	device: &Device,
	micromap_count: u32,
	p_micromaps: *const vk::MicromapEXT,
	query_type: vk::QueryType,
	data_size: usize,
	p_data: *mut std::ffi::c_void,
	stride: usize,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.write_micromaps_properties_ext
		.ok_or(CallError::MissingCommand("vkWriteMicromapsPropertiesEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			micromap_count,
			p_micromaps,
			query_type,
			data_size,
			p_data,
			stride,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkWriteMicromapsPropertiesEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkWriteMicromapsPropertiesEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkWriteMicromapsPropertiesEXT")]
	#[doc = "\n\n[Khronos reference: `vkWriteMicromapsPropertiesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkWriteMicromapsPropertiesEXT.html)"]
	#[inline]
	pub unsafe fn write_micromaps_properties_ext(
		&self,
		micromap_count: u32,
		p_micromaps: *const vk::MicromapEXT,
		query_type: vk::QueryType,
		data_size: usize,
		p_data: *mut std::ffi::c_void,
		stride: usize,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			write_micromaps_properties_ext(
				self,
				micromap_count,
				p_micromaps,
				query_type,
				data_size,
				p_data,
				stride,
			)
		}
	}
}

/// Call `vkGetDeviceMicromapCompatibilityEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceMicromapCompatibilityEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeviceMicromapCompatibilityEXT")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceMicromapCompatibilityEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceMicromapCompatibilityEXT.html)"]
pub unsafe fn get_device_micromap_compatibility_ext(
	device: &Device,
	p_version_info: *const vk::MicromapVersionInfoEXT<'_>,
	p_compatibility: *mut vk::AccelerationStructureCompatibilityKHR,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.get_device_micromap_compatibility_ext
			.ok_or(CallError::MissingCommand(
				"vkGetDeviceMicromapCompatibilityEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_version_info, p_compatibility) };
	Ok(())
}

impl Device {
	/// Call `vkGetDeviceMicromapCompatibilityEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceMicromapCompatibilityEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeviceMicromapCompatibilityEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceMicromapCompatibilityEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceMicromapCompatibilityEXT.html)"]
	#[inline]
	pub unsafe fn get_device_micromap_compatibility_ext(
		&self,
		p_version_info: *const vk::MicromapVersionInfoEXT<'_>,
		p_compatibility: *mut vk::AccelerationStructureCompatibilityKHR,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_device_micromap_compatibility_ext(self, p_version_info, p_compatibility) }
	}
}

/// Call `vkGetMicromapBuildSizesEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetMicromapBuildSizesEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetMicromapBuildSizesEXT")]
#[doc = "\n\n[Khronos reference: `vkGetMicromapBuildSizesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMicromapBuildSizesEXT.html)"]
pub unsafe fn get_micromap_build_sizes_ext(
	device: &Device,
	build_type: vk::AccelerationStructureBuildTypeKHR,
	p_build_info: *const vk::MicromapBuildInfoEXT<'_>,
	p_size_info: *mut vk::MicromapBuildSizesInfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_micromap_build_sizes_ext
		.ok_or(CallError::MissingCommand("vkGetMicromapBuildSizesEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), build_type, p_build_info, p_size_info) };
	Ok(())
}

impl Device {
	/// Call `vkGetMicromapBuildSizesEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetMicromapBuildSizesEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetMicromapBuildSizesEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetMicromapBuildSizesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMicromapBuildSizesEXT.html)"]
	#[inline]
	pub unsafe fn get_micromap_build_sizes_ext(
		&self,
		build_type: vk::AccelerationStructureBuildTypeKHR,
		p_build_info: *const vk::MicromapBuildInfoEXT<'_>,
		p_size_info: *mut vk::MicromapBuildSizesInfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_micromap_build_sizes_ext(self, build_type, p_build_info, p_size_info) }
	}
}

/// Call `vkGetShaderModuleIdentifierEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetShaderModuleIdentifierEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetShaderModuleIdentifierEXT")]
#[doc = "\n\n[Khronos reference: `vkGetShaderModuleIdentifierEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetShaderModuleIdentifierEXT.html)"]
pub unsafe fn get_shader_module_identifier_ext(
	device: &Device,
	shader_module: vk::ShaderModule,
	p_identifier: *mut vk::ShaderModuleIdentifierEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_shader_module_identifier_ext
		.ok_or(CallError::MissingCommand("vkGetShaderModuleIdentifierEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), shader_module, p_identifier) };
	Ok(())
}

impl Device {
	/// Call `vkGetShaderModuleIdentifierEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetShaderModuleIdentifierEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetShaderModuleIdentifierEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetShaderModuleIdentifierEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetShaderModuleIdentifierEXT.html)"]
	#[inline]
	pub unsafe fn get_shader_module_identifier_ext(
		&self,
		shader_module: vk::ShaderModule,
		p_identifier: *mut vk::ShaderModuleIdentifierEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_shader_module_identifier_ext(self, shader_module, p_identifier) }
	}
}

/// Call `vkGetShaderModuleCreateInfoIdentifierEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetShaderModuleCreateInfoIdentifierEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetShaderModuleCreateInfoIdentifierEXT")]
#[doc = "\n\n[Khronos reference: `vkGetShaderModuleCreateInfoIdentifierEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetShaderModuleCreateInfoIdentifierEXT.html)"]
pub unsafe fn get_shader_module_create_info_identifier_ext(
	device: &Device,
	p_create_info: *const vk::ShaderModuleCreateInfo<'_>,
	p_identifier: *mut vk::ShaderModuleIdentifierEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_shader_module_create_info_identifier_ext
		.ok_or(CallError::MissingCommand(
			"vkGetShaderModuleCreateInfoIdentifierEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_create_info, p_identifier) };
	Ok(())
}

impl Device {
	/// Call `vkGetShaderModuleCreateInfoIdentifierEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetShaderModuleCreateInfoIdentifierEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetShaderModuleCreateInfoIdentifierEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetShaderModuleCreateInfoIdentifierEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetShaderModuleCreateInfoIdentifierEXT.html)"]
	#[inline]
	pub unsafe fn get_shader_module_create_info_identifier_ext(
		&self,
		p_create_info: *const vk::ShaderModuleCreateInfo<'_>,
		p_identifier: *mut vk::ShaderModuleIdentifierEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_shader_module_create_info_identifier_ext(self, p_create_info, p_identifier) }
	}
}

/// Call `vkGetImageSubresourceLayout2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetImageSubresourceLayout2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetImageSubresourceLayout2")]
#[doc = "\n\n[Khronos reference: `vkGetImageSubresourceLayout2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageSubresourceLayout2.html)"]
pub unsafe fn get_image_subresource_layout2(
	device: &Device,
	image: vk::Image,
	p_subresource: *const vk::ImageSubresource2<'_>,
	p_layout: *mut vk::SubresourceLayout2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_image_subresource_layout2
		.ok_or(CallError::MissingCommand("vkGetImageSubresourceLayout2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), image, p_subresource, p_layout) };
	Ok(())
}

impl Device {
	/// Call `vkGetImageSubresourceLayout2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetImageSubresourceLayout2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetImageSubresourceLayout2")]
	#[doc = "\n\n[Khronos reference: `vkGetImageSubresourceLayout2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageSubresourceLayout2.html)"]
	#[inline]
	pub unsafe fn get_image_subresource_layout2(
		&self,
		image: vk::Image,
		p_subresource: *const vk::ImageSubresource2<'_>,
		p_layout: *mut vk::SubresourceLayout2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_image_subresource_layout2(self, image, p_subresource, p_layout) }
	}
}

/// Call `vkGetImageSubresourceLayout2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetImageSubresourceLayout2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetImageSubresourceLayout2KHR")]
#[doc = "\n\n[Khronos reference: `vkGetImageSubresourceLayout2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageSubresourceLayout2KHR.html)"]
pub unsafe fn get_image_subresource_layout2_khr(
	device: &Device,
	image: vk::Image,
	p_subresource: *const vk::ImageSubresource2<'_>,
	p_layout: *mut vk::SubresourceLayout2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_image_subresource_layout2_khr
		.ok_or(CallError::MissingCommand("vkGetImageSubresourceLayout2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), image, p_subresource, p_layout) };
	Ok(())
}

impl Device {
	/// Call `vkGetImageSubresourceLayout2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetImageSubresourceLayout2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetImageSubresourceLayout2KHR")]
	#[doc = "\n\n[Khronos reference: `vkGetImageSubresourceLayout2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageSubresourceLayout2KHR.html)"]
	#[inline]
	pub unsafe fn get_image_subresource_layout2_khr(
		&self,
		image: vk::Image,
		p_subresource: *const vk::ImageSubresource2<'_>,
		p_layout: *mut vk::SubresourceLayout2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_image_subresource_layout2_khr(self, image, p_subresource, p_layout) }
	}
}

/// Call `vkGetImageSubresourceLayout2EXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetImageSubresourceLayout2EXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetImageSubresourceLayout2EXT")]
#[doc = "\n\n[Khronos reference: `vkGetImageSubresourceLayout2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageSubresourceLayout2EXT.html)"]
pub unsafe fn get_image_subresource_layout2_ext(
	device: &Device,
	image: vk::Image,
	p_subresource: *const vk::ImageSubresource2<'_>,
	p_layout: *mut vk::SubresourceLayout2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_image_subresource_layout2_ext
		.ok_or(CallError::MissingCommand("vkGetImageSubresourceLayout2EXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), image, p_subresource, p_layout) };
	Ok(())
}

impl Device {
	/// Call `vkGetImageSubresourceLayout2EXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetImageSubresourceLayout2EXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetImageSubresourceLayout2EXT")]
	#[doc = "\n\n[Khronos reference: `vkGetImageSubresourceLayout2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageSubresourceLayout2EXT.html)"]
	#[inline]
	pub unsafe fn get_image_subresource_layout2_ext(
		&self,
		image: vk::Image,
		p_subresource: *const vk::ImageSubresource2<'_>,
		p_layout: *mut vk::SubresourceLayout2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_image_subresource_layout2_ext(self, image, p_subresource, p_layout) }
	}
}

/// Call `vkGetPipelinePropertiesEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPipelinePropertiesEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPipelinePropertiesEXT")]
#[doc = "\n\n[Khronos reference: `vkGetPipelinePropertiesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPipelinePropertiesEXT.html)"]
pub unsafe fn get_pipeline_properties_ext(
	device: &Device,
	p_pipeline_info: *const vk::PipelineInfoKHR<'_>,
	p_pipeline_properties: *mut vk::BaseOutStructure<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_pipeline_properties_ext
		.ok_or(CallError::MissingCommand("vkGetPipelinePropertiesEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_pipeline_info, p_pipeline_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetPipelinePropertiesEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPipelinePropertiesEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPipelinePropertiesEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetPipelinePropertiesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPipelinePropertiesEXT.html)"]
	#[inline]
	pub unsafe fn get_pipeline_properties_ext(
		&self,
		p_pipeline_info: *const vk::PipelineInfoKHR<'_>,
		p_pipeline_properties: *mut vk::BaseOutStructure<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_pipeline_properties_ext(self, p_pipeline_info, p_pipeline_properties) }
	}
}

#[cfg(feature = "platform-metal")]
/// Call `vkExportMetalObjectsEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkExportMetalObjectsEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkExportMetalObjectsEXT")]
#[doc = "\n\n[Khronos reference: `vkExportMetalObjectsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkExportMetalObjectsEXT.html)"]
pub unsafe fn export_metal_objects_ext(
	device: &Device,
	p_metal_objects_info: *mut vk::ExportMetalObjectsInfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.export_metal_objects_ext
		.ok_or(CallError::MissingCommand("vkExportMetalObjectsEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_metal_objects_info) };
	Ok(())
}

#[cfg(feature = "platform-metal")]
impl Device {
	/// Call `vkExportMetalObjectsEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkExportMetalObjectsEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkExportMetalObjectsEXT")]
	#[doc = "\n\n[Khronos reference: `vkExportMetalObjectsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkExportMetalObjectsEXT.html)"]
	#[inline]
	pub unsafe fn export_metal_objects_ext(
		&self,
		p_metal_objects_info: *mut vk::ExportMetalObjectsInfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { export_metal_objects_ext(self, p_metal_objects_info) }
	}
}

/// Call `vkCmdBindTileMemoryQCOM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindTileMemoryQCOM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBindTileMemoryQCOM")]
#[doc = "\n\n[Khronos reference: `vkCmdBindTileMemoryQCOM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindTileMemoryQCOM.html)"]
pub unsafe fn cmd_bind_tile_memory_qcom(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_tile_memory_bind_info: *const vk::TileMemoryBindInfoQCOM<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_tile_memory_qcom
		.ok_or(CallError::MissingCommand("vkCmdBindTileMemoryQCOM"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_tile_memory_bind_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBindTileMemoryQCOM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindTileMemoryQCOM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBindTileMemoryQCOM")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindTileMemoryQCOM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindTileMemoryQCOM.html)"]
	#[inline]
	pub unsafe fn cmd_bind_tile_memory_qcom(
		&self,
		command_buffer: vk::CommandBuffer,
		p_tile_memory_bind_info: *const vk::TileMemoryBindInfoQCOM<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_bind_tile_memory_qcom(self, command_buffer, p_tile_memory_bind_info) }
	}
}

/// Call `vkGetFramebufferTilePropertiesQCOM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetFramebufferTilePropertiesQCOM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetFramebufferTilePropertiesQCOM")]
#[doc = "\n\n[Khronos reference: `vkGetFramebufferTilePropertiesQCOM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetFramebufferTilePropertiesQCOM.html)"]
pub unsafe fn get_framebuffer_tile_properties_qcom(
	device: &Device,
	framebuffer: vk::Framebuffer,
	p_properties_count: *mut u32,
	p_properties: *mut vk::TilePropertiesQCOM<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.get_framebuffer_tile_properties_qcom
			.ok_or(CallError::MissingCommand(
				"vkGetFramebufferTilePropertiesQCOM",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			framebuffer,
			p_properties_count,
			p_properties,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetFramebufferTilePropertiesQCOM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetFramebufferTilePropertiesQCOM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetFramebufferTilePropertiesQCOM")]
	#[doc = "\n\n[Khronos reference: `vkGetFramebufferTilePropertiesQCOM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetFramebufferTilePropertiesQCOM.html)"]
	#[inline]
	pub unsafe fn get_framebuffer_tile_properties_qcom(
		&self,
		framebuffer: vk::Framebuffer,
		p_properties_count: *mut u32,
		p_properties: *mut vk::TilePropertiesQCOM<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_framebuffer_tile_properties_qcom(self, framebuffer, p_properties_count, p_properties)
		}
	}
}

/// Call `vkGetDynamicRenderingTilePropertiesQCOM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDynamicRenderingTilePropertiesQCOM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDynamicRenderingTilePropertiesQCOM")]
#[doc = "\n\n[Khronos reference: `vkGetDynamicRenderingTilePropertiesQCOM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDynamicRenderingTilePropertiesQCOM.html)"]
pub unsafe fn get_dynamic_rendering_tile_properties_qcom(
	device: &Device,
	p_rendering_info: *const vk::RenderingInfo<'_>,
	p_properties: *mut vk::TilePropertiesQCOM<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_dynamic_rendering_tile_properties_qcom
		.ok_or(CallError::MissingCommand(
			"vkGetDynamicRenderingTilePropertiesQCOM",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_rendering_info, p_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetDynamicRenderingTilePropertiesQCOM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDynamicRenderingTilePropertiesQCOM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDynamicRenderingTilePropertiesQCOM")]
	#[doc = "\n\n[Khronos reference: `vkGetDynamicRenderingTilePropertiesQCOM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDynamicRenderingTilePropertiesQCOM.html)"]
	#[inline]
	pub unsafe fn get_dynamic_rendering_tile_properties_qcom(
		&self,
		p_rendering_info: *const vk::RenderingInfo<'_>,
		p_properties: *mut vk::TilePropertiesQCOM<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_dynamic_rendering_tile_properties_qcom(self, p_rendering_info, p_properties) }
	}
}

/// Call `vkGetPhysicalDeviceOpticalFlowImageFormatsNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceOpticalFlowImageFormatsNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceOpticalFlowImageFormatsNV")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceOpticalFlowImageFormatsNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html)"]
pub unsafe fn get_physical_device_optical_flow_image_formats_nv(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_optical_flow_image_format_info: *const vk::OpticalFlowImageFormatInfoNV<'_>,
	p_format_count: *mut u32,
	p_image_format_properties: *mut vk::OpticalFlowImageFormatPropertiesNV<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_optical_flow_image_formats_nv
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceOpticalFlowImageFormatsNV",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			physical_device,
			p_optical_flow_image_format_info,
			p_format_count,
			p_image_format_properties,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceOpticalFlowImageFormatsNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceOpticalFlowImageFormatsNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceOpticalFlowImageFormatsNV")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceOpticalFlowImageFormatsNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html)"]
	#[inline]
	pub unsafe fn get_physical_device_optical_flow_image_formats_nv(
		&self,
		physical_device: vk::PhysicalDevice,
		p_optical_flow_image_format_info: *const vk::OpticalFlowImageFormatInfoNV<'_>,
		p_format_count: *mut u32,
		p_image_format_properties: *mut vk::OpticalFlowImageFormatPropertiesNV<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_optical_flow_image_formats_nv(
				self,
				physical_device,
				p_optical_flow_image_format_info,
				p_format_count,
				p_image_format_properties,
			)
		}
	}
}

/// Call `vkCreateOpticalFlowSessionNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateOpticalFlowSessionNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateOpticalFlowSessionNV")]
#[doc = "\n\n[Khronos reference: `vkCreateOpticalFlowSessionNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateOpticalFlowSessionNV.html)"]
pub unsafe fn create_optical_flow_session_nv(
	device: &Device,
	p_create_info: *const vk::OpticalFlowSessionCreateInfoNV<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_session: *mut vk::OpticalFlowSessionNV,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_optical_flow_session_nv
		.ok_or(CallError::MissingCommand("vkCreateOpticalFlowSessionNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_create_info, p_allocator, p_session) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateOpticalFlowSessionNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateOpticalFlowSessionNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateOpticalFlowSessionNV")]
	#[doc = "\n\n[Khronos reference: `vkCreateOpticalFlowSessionNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateOpticalFlowSessionNV.html)"]
	#[inline]
	pub unsafe fn create_optical_flow_session_nv(
		&self,
		p_create_info: *const vk::OpticalFlowSessionCreateInfoNV<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_session: *mut vk::OpticalFlowSessionNV,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_optical_flow_session_nv(self, p_create_info, p_allocator, p_session) }
	}
}

/// Call `vkDestroyOpticalFlowSessionNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyOpticalFlowSessionNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyOpticalFlowSessionNV")]
#[doc = "\n\n[Khronos reference: `vkDestroyOpticalFlowSessionNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyOpticalFlowSessionNV.html)"]
pub unsafe fn destroy_optical_flow_session_nv(
	device: &Device,
	session: vk::OpticalFlowSessionNV,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_optical_flow_session_nv
		.ok_or(CallError::MissingCommand("vkDestroyOpticalFlowSessionNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), session, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyOpticalFlowSessionNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyOpticalFlowSessionNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyOpticalFlowSessionNV")]
	#[doc = "\n\n[Khronos reference: `vkDestroyOpticalFlowSessionNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyOpticalFlowSessionNV.html)"]
	#[inline]
	pub unsafe fn destroy_optical_flow_session_nv(
		&self,
		session: vk::OpticalFlowSessionNV,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_optical_flow_session_nv(self, session, p_allocator) }
	}
}

/// Call `vkBindOpticalFlowSessionImageNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkBindOpticalFlowSessionImageNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkBindOpticalFlowSessionImageNV")]
#[doc = "\n\n[Khronos reference: `vkBindOpticalFlowSessionImageNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBindOpticalFlowSessionImageNV.html)"]
pub unsafe fn bind_optical_flow_session_image_nv(
	device: &Device,
	session: vk::OpticalFlowSessionNV,
	binding_point: vk::OpticalFlowSessionBindingPointNV,
	view: vk::ImageView,
	layout: vk::ImageLayout,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.bind_optical_flow_session_image_nv
		.ok_or(CallError::MissingCommand("vkBindOpticalFlowSessionImageNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), session, binding_point, view, layout) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkBindOpticalFlowSessionImageNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkBindOpticalFlowSessionImageNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkBindOpticalFlowSessionImageNV")]
	#[doc = "\n\n[Khronos reference: `vkBindOpticalFlowSessionImageNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBindOpticalFlowSessionImageNV.html)"]
	#[inline]
	pub unsafe fn bind_optical_flow_session_image_nv(
		&self,
		session: vk::OpticalFlowSessionNV,
		binding_point: vk::OpticalFlowSessionBindingPointNV,
		view: vk::ImageView,
		layout: vk::ImageLayout,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { bind_optical_flow_session_image_nv(self, session, binding_point, view, layout) }
	}
}

/// Call `vkCmdOpticalFlowExecuteNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdOpticalFlowExecuteNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdOpticalFlowExecuteNV")]
#[doc = "\n\n[Khronos reference: `vkCmdOpticalFlowExecuteNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdOpticalFlowExecuteNV.html)"]
pub unsafe fn cmd_optical_flow_execute_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	session: vk::OpticalFlowSessionNV,
	p_execute_info: *const vk::OpticalFlowExecuteInfoNV<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_optical_flow_execute_nv
		.ok_or(CallError::MissingCommand("vkCmdOpticalFlowExecuteNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, session, p_execute_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdOpticalFlowExecuteNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdOpticalFlowExecuteNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdOpticalFlowExecuteNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdOpticalFlowExecuteNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdOpticalFlowExecuteNV.html)"]
	#[inline]
	pub unsafe fn cmd_optical_flow_execute_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		session: vk::OpticalFlowSessionNV,
		p_execute_info: *const vk::OpticalFlowExecuteInfoNV<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_optical_flow_execute_nv(self, command_buffer, session, p_execute_info) }
	}
}

/// Call `vkGetDeviceFaultInfoEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceFaultInfoEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeviceFaultInfoEXT")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceFaultInfoEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceFaultInfoEXT.html)"]
pub unsafe fn get_device_fault_info_ext(
	device: &Device,
	p_fault_counts: *mut vk::DeviceFaultCountsEXT<'_>,
	p_fault_info: *mut vk::DeviceFaultInfoEXT<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_device_fault_info_ext
		.ok_or(CallError::MissingCommand("vkGetDeviceFaultInfoEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_fault_counts, p_fault_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetDeviceFaultInfoEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceFaultInfoEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeviceFaultInfoEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceFaultInfoEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceFaultInfoEXT.html)"]
	#[inline]
	pub unsafe fn get_device_fault_info_ext(
		&self,
		p_fault_counts: *mut vk::DeviceFaultCountsEXT<'_>,
		p_fault_info: *mut vk::DeviceFaultInfoEXT<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_device_fault_info_ext(self, p_fault_counts, p_fault_info) }
	}
}

/// Call `vkGetDeviceFaultReportsKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceFaultReportsKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeviceFaultReportsKHR")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceFaultReportsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceFaultReportsKHR.html)"]
pub unsafe fn get_device_fault_reports_khr(
	device: &Device,
	timeout: u64,
	p_fault_counts: *mut u32,
	p_fault_info: *mut vk::DeviceFaultInfoKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_device_fault_reports_khr
		.ok_or(CallError::MissingCommand("vkGetDeviceFaultReportsKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), timeout, p_fault_counts, p_fault_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetDeviceFaultReportsKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceFaultReportsKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeviceFaultReportsKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceFaultReportsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceFaultReportsKHR.html)"]
	#[inline]
	pub unsafe fn get_device_fault_reports_khr(
		&self,
		timeout: u64,
		p_fault_counts: *mut u32,
		p_fault_info: *mut vk::DeviceFaultInfoKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_device_fault_reports_khr(self, timeout, p_fault_counts, p_fault_info) }
	}
}

/// Call `vkGetDeviceFaultDebugInfoKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceFaultDebugInfoKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeviceFaultDebugInfoKHR")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceFaultDebugInfoKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceFaultDebugInfoKHR.html)"]
pub unsafe fn get_device_fault_debug_info_khr(
	device: &Device,
	p_debug_info: *mut vk::DeviceFaultDebugInfoKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_device_fault_debug_info_khr
		.ok_or(CallError::MissingCommand("vkGetDeviceFaultDebugInfoKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_debug_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetDeviceFaultDebugInfoKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceFaultDebugInfoKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeviceFaultDebugInfoKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceFaultDebugInfoKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceFaultDebugInfoKHR.html)"]
	#[inline]
	pub unsafe fn get_device_fault_debug_info_khr(
		&self,
		p_debug_info: *mut vk::DeviceFaultDebugInfoKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_device_fault_debug_info_khr(self, p_debug_info) }
	}
}

/// Call `vkCmdSetDepthBias2EXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDepthBias2EXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDepthBias2EXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDepthBias2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthBias2EXT.html)"]
pub unsafe fn cmd_set_depth_bias2_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_depth_bias_info: *const vk::DepthBiasInfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_depth_bias2_ext
		.ok_or(CallError::MissingCommand("vkCmdSetDepthBias2EXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_depth_bias_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDepthBias2EXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDepthBias2EXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDepthBias2EXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDepthBias2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthBias2EXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_depth_bias2_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_depth_bias_info: *const vk::DepthBiasInfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_depth_bias2_ext(self, command_buffer, p_depth_bias_info) }
	}
}

/// Call `vkReleaseSwapchainImagesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkReleaseSwapchainImagesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkReleaseSwapchainImagesKHR")]
#[doc = "\n\n[Khronos reference: `vkReleaseSwapchainImagesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkReleaseSwapchainImagesKHR.html)"]
pub unsafe fn release_swapchain_images_khr(
	device: &Device,
	p_release_info: *const vk::ReleaseSwapchainImagesInfoKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.release_swapchain_images_khr
		.ok_or(CallError::MissingCommand("vkReleaseSwapchainImagesKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_release_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkReleaseSwapchainImagesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkReleaseSwapchainImagesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkReleaseSwapchainImagesKHR")]
	#[doc = "\n\n[Khronos reference: `vkReleaseSwapchainImagesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkReleaseSwapchainImagesKHR.html)"]
	#[inline]
	pub unsafe fn release_swapchain_images_khr(
		&self,
		p_release_info: *const vk::ReleaseSwapchainImagesInfoKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { release_swapchain_images_khr(self, p_release_info) }
	}
}

/// Call `vkReleaseSwapchainImagesEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkReleaseSwapchainImagesEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkReleaseSwapchainImagesEXT")]
#[doc = "\n\n[Khronos reference: `vkReleaseSwapchainImagesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkReleaseSwapchainImagesEXT.html)"]
pub unsafe fn release_swapchain_images_ext(
	device: &Device,
	p_release_info: *const vk::ReleaseSwapchainImagesInfoKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.release_swapchain_images_ext
		.ok_or(CallError::MissingCommand("vkReleaseSwapchainImagesEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_release_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkReleaseSwapchainImagesEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkReleaseSwapchainImagesEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkReleaseSwapchainImagesEXT")]
	#[doc = "\n\n[Khronos reference: `vkReleaseSwapchainImagesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkReleaseSwapchainImagesEXT.html)"]
	#[inline]
	pub unsafe fn release_swapchain_images_ext(
		&self,
		p_release_info: *const vk::ReleaseSwapchainImagesInfoKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { release_swapchain_images_ext(self, p_release_info) }
	}
}

/// Call `vkGetDeviceImageSubresourceLayout` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceImageSubresourceLayout` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeviceImageSubresourceLayout")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceImageSubresourceLayout`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceImageSubresourceLayout.html)"]
pub unsafe fn get_device_image_subresource_layout(
	device: &Device,
	p_info: *const vk::DeviceImageSubresourceInfo<'_>,
	p_layout: *mut vk::SubresourceLayout2<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.get_device_image_subresource_layout
			.ok_or(CallError::MissingCommand(
				"vkGetDeviceImageSubresourceLayout",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_info, p_layout) };
	Ok(())
}

impl Device {
	/// Call `vkGetDeviceImageSubresourceLayout` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceImageSubresourceLayout` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeviceImageSubresourceLayout")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceImageSubresourceLayout`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceImageSubresourceLayout.html)"]
	#[inline]
	pub unsafe fn get_device_image_subresource_layout(
		&self,
		p_info: *const vk::DeviceImageSubresourceInfo<'_>,
		p_layout: *mut vk::SubresourceLayout2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_device_image_subresource_layout(self, p_info, p_layout) }
	}
}

/// Call `vkGetDeviceImageSubresourceLayoutKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceImageSubresourceLayoutKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeviceImageSubresourceLayoutKHR")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceImageSubresourceLayoutKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceImageSubresourceLayoutKHR.html)"]
pub unsafe fn get_device_image_subresource_layout_khr(
	device: &Device,
	p_info: *const vk::DeviceImageSubresourceInfo<'_>,
	p_layout: *mut vk::SubresourceLayout2<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.get_device_image_subresource_layout_khr
			.ok_or(CallError::MissingCommand(
				"vkGetDeviceImageSubresourceLayoutKHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_info, p_layout) };
	Ok(())
}

impl Device {
	/// Call `vkGetDeviceImageSubresourceLayoutKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceImageSubresourceLayoutKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeviceImageSubresourceLayoutKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceImageSubresourceLayoutKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceImageSubresourceLayoutKHR.html)"]
	#[inline]
	pub unsafe fn get_device_image_subresource_layout_khr(
		&self,
		p_info: *const vk::DeviceImageSubresourceInfo<'_>,
		p_layout: *mut vk::SubresourceLayout2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_device_image_subresource_layout_khr(self, p_info, p_layout) }
	}
}

/// Call `vkMapMemory2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkMapMemory2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkMapMemory2")]
#[doc = "\n\n[Khronos reference: `vkMapMemory2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkMapMemory2.html)"]
pub unsafe fn map_memory2(
	device: &Device,
	p_memory_map_info: *const vk::MemoryMapInfo<'_>,
	pp_data: *mut *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.map_memory2
		.ok_or(CallError::MissingCommand("vkMapMemory2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_memory_map_info, pp_data) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkMapMemory2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkMapMemory2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkMapMemory2")]
	#[doc = "\n\n[Khronos reference: `vkMapMemory2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkMapMemory2.html)"]
	#[inline]
	pub unsafe fn map_memory2(
		&self,
		p_memory_map_info: *const vk::MemoryMapInfo<'_>,
		pp_data: *mut *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { map_memory2(self, p_memory_map_info, pp_data) }
	}
}

/// Call `vkMapMemory2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkMapMemory2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkMapMemory2KHR")]
#[doc = "\n\n[Khronos reference: `vkMapMemory2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkMapMemory2KHR.html)"]
pub unsafe fn map_memory2_khr(
	device: &Device,
	p_memory_map_info: *const vk::MemoryMapInfo<'_>,
	pp_data: *mut *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.map_memory2_khr
		.ok_or(CallError::MissingCommand("vkMapMemory2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_memory_map_info, pp_data) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkMapMemory2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkMapMemory2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkMapMemory2KHR")]
	#[doc = "\n\n[Khronos reference: `vkMapMemory2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkMapMemory2KHR.html)"]
	#[inline]
	pub unsafe fn map_memory2_khr(
		&self,
		p_memory_map_info: *const vk::MemoryMapInfo<'_>,
		pp_data: *mut *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { map_memory2_khr(self, p_memory_map_info, pp_data) }
	}
}

/// Call `vkUnmapMemory2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkUnmapMemory2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkUnmapMemory2")]
#[doc = "\n\n[Khronos reference: `vkUnmapMemory2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkUnmapMemory2.html)"]
pub unsafe fn unmap_memory2(
	device: &Device,
	p_memory_unmap_info: *const vk::MemoryUnmapInfo<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.unmap_memory2
		.ok_or(CallError::MissingCommand("vkUnmapMemory2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_memory_unmap_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkUnmapMemory2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkUnmapMemory2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkUnmapMemory2")]
	#[doc = "\n\n[Khronos reference: `vkUnmapMemory2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkUnmapMemory2.html)"]
	#[inline]
	pub unsafe fn unmap_memory2(
		&self,
		p_memory_unmap_info: *const vk::MemoryUnmapInfo<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { unmap_memory2(self, p_memory_unmap_info) }
	}
}

/// Call `vkUnmapMemory2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkUnmapMemory2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkUnmapMemory2KHR")]
#[doc = "\n\n[Khronos reference: `vkUnmapMemory2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkUnmapMemory2KHR.html)"]
pub unsafe fn unmap_memory2_khr(
	device: &Device,
	p_memory_unmap_info: *const vk::MemoryUnmapInfo<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.unmap_memory2_khr
		.ok_or(CallError::MissingCommand("vkUnmapMemory2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_memory_unmap_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkUnmapMemory2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkUnmapMemory2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkUnmapMemory2KHR")]
	#[doc = "\n\n[Khronos reference: `vkUnmapMemory2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkUnmapMemory2KHR.html)"]
	#[inline]
	pub unsafe fn unmap_memory2_khr(
		&self,
		p_memory_unmap_info: *const vk::MemoryUnmapInfo<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { unmap_memory2_khr(self, p_memory_unmap_info) }
	}
}

/// Call `vkCreateShadersEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateShadersEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateShadersEXT")]
#[doc = "\n\n[Khronos reference: `vkCreateShadersEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateShadersEXT.html)"]
pub unsafe fn create_shaders_ext(
	device: &Device,
	create_info_count: u32,
	p_create_infos: *const vk::ShaderCreateInfoEXT<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_shaders: *mut vk::ShaderEXT,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_shaders_ext
		.ok_or(CallError::MissingCommand("vkCreateShadersEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			create_info_count,
			p_create_infos,
			p_allocator,
			p_shaders,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateShadersEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateShadersEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateShadersEXT")]
	#[doc = "\n\n[Khronos reference: `vkCreateShadersEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateShadersEXT.html)"]
	#[inline]
	pub unsafe fn create_shaders_ext(
		&self,
		create_info_count: u32,
		p_create_infos: *const vk::ShaderCreateInfoEXT<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_shaders: *mut vk::ShaderEXT,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			create_shaders_ext(
				self,
				create_info_count,
				p_create_infos,
				p_allocator,
				p_shaders,
			)
		}
	}
}

/// Call `vkDestroyShaderEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyShaderEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyShaderEXT")]
#[doc = "\n\n[Khronos reference: `vkDestroyShaderEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyShaderEXT.html)"]
pub unsafe fn destroy_shader_ext(
	device: &Device,
	shader: vk::ShaderEXT,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_shader_ext
		.ok_or(CallError::MissingCommand("vkDestroyShaderEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), shader, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyShaderEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyShaderEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyShaderEXT")]
	#[doc = "\n\n[Khronos reference: `vkDestroyShaderEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyShaderEXT.html)"]
	#[inline]
	pub unsafe fn destroy_shader_ext(
		&self,
		shader: vk::ShaderEXT,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_shader_ext(self, shader, p_allocator) }
	}
}

/// Call `vkGetShaderBinaryDataEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetShaderBinaryDataEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetShaderBinaryDataEXT")]
#[doc = "\n\n[Khronos reference: `vkGetShaderBinaryDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetShaderBinaryDataEXT.html)"]
pub unsafe fn get_shader_binary_data_ext(
	device: &Device,
	shader: vk::ShaderEXT,
	p_data_size: *mut usize,
	p_data: *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_shader_binary_data_ext
		.ok_or(CallError::MissingCommand("vkGetShaderBinaryDataEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), shader, p_data_size, p_data) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetShaderBinaryDataEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetShaderBinaryDataEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetShaderBinaryDataEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetShaderBinaryDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetShaderBinaryDataEXT.html)"]
	#[inline]
	pub unsafe fn get_shader_binary_data_ext(
		&self,
		shader: vk::ShaderEXT,
		p_data_size: *mut usize,
		p_data: *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_shader_binary_data_ext(self, shader, p_data_size, p_data) }
	}
}

/// Call `vkCmdBindShadersEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindShadersEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBindShadersEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdBindShadersEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindShadersEXT.html)"]
pub unsafe fn cmd_bind_shaders_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	stage_count: u32,
	p_stages: *const vk::ShaderStageFlagBits,
	p_shaders: *const vk::ShaderEXT,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_shaders_ext
		.ok_or(CallError::MissingCommand("vkCmdBindShadersEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, stage_count, p_stages, p_shaders) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBindShadersEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindShadersEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBindShadersEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindShadersEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindShadersEXT.html)"]
	#[inline]
	pub unsafe fn cmd_bind_shaders_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		stage_count: u32,
		p_stages: *const vk::ShaderStageFlagBits,
		p_shaders: *const vk::ShaderEXT,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_bind_shaders_ext(self, command_buffer, stage_count, p_stages, p_shaders) }
	}
}

/// Call `vkSetSwapchainPresentTimingQueueSizeEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkSetSwapchainPresentTimingQueueSizeEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkSetSwapchainPresentTimingQueueSizeEXT")]
#[doc = "\n\n[Khronos reference: `vkSetSwapchainPresentTimingQueueSizeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetSwapchainPresentTimingQueueSizeEXT.html)"]
pub unsafe fn set_swapchain_present_timing_queue_size_ext(
	device: &Device,
	swapchain: vk::SwapchainKHR,
	size: u32,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.set_swapchain_present_timing_queue_size_ext
		.ok_or(CallError::MissingCommand(
			"vkSetSwapchainPresentTimingQueueSizeEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), swapchain, size) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkSetSwapchainPresentTimingQueueSizeEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkSetSwapchainPresentTimingQueueSizeEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkSetSwapchainPresentTimingQueueSizeEXT")]
	#[doc = "\n\n[Khronos reference: `vkSetSwapchainPresentTimingQueueSizeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetSwapchainPresentTimingQueueSizeEXT.html)"]
	#[inline]
	pub unsafe fn set_swapchain_present_timing_queue_size_ext(
		&self,
		swapchain: vk::SwapchainKHR,
		size: u32,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { set_swapchain_present_timing_queue_size_ext(self, swapchain, size) }
	}
}

/// Call `vkGetSwapchainTimingPropertiesEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetSwapchainTimingPropertiesEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetSwapchainTimingPropertiesEXT")]
#[doc = "\n\n[Khronos reference: `vkGetSwapchainTimingPropertiesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSwapchainTimingPropertiesEXT.html)"]
pub unsafe fn get_swapchain_timing_properties_ext(
	device: &Device,
	swapchain: vk::SwapchainKHR,
	p_swapchain_timing_properties: *mut vk::SwapchainTimingPropertiesEXT<'_>,
	p_swapchain_timing_properties_counter: *mut u64,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.get_swapchain_timing_properties_ext
			.ok_or(CallError::MissingCommand(
				"vkGetSwapchainTimingPropertiesEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			swapchain,
			p_swapchain_timing_properties,
			p_swapchain_timing_properties_counter,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetSwapchainTimingPropertiesEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetSwapchainTimingPropertiesEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetSwapchainTimingPropertiesEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetSwapchainTimingPropertiesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSwapchainTimingPropertiesEXT.html)"]
	#[inline]
	pub unsafe fn get_swapchain_timing_properties_ext(
		&self,
		swapchain: vk::SwapchainKHR,
		p_swapchain_timing_properties: *mut vk::SwapchainTimingPropertiesEXT<'_>,
		p_swapchain_timing_properties_counter: *mut u64,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_swapchain_timing_properties_ext(
				self,
				swapchain,
				p_swapchain_timing_properties,
				p_swapchain_timing_properties_counter,
			)
		}
	}
}

/// Call `vkGetSwapchainTimeDomainPropertiesEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetSwapchainTimeDomainPropertiesEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetSwapchainTimeDomainPropertiesEXT")]
#[doc = "\n\n[Khronos reference: `vkGetSwapchainTimeDomainPropertiesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSwapchainTimeDomainPropertiesEXT.html)"]
pub unsafe fn get_swapchain_time_domain_properties_ext(
	device: &Device,
	swapchain: vk::SwapchainKHR,
	p_swapchain_time_domain_properties: *mut vk::SwapchainTimeDomainPropertiesEXT<'_>,
	p_time_domains_counter: *mut u64,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.get_swapchain_time_domain_properties_ext
			.ok_or(CallError::MissingCommand(
				"vkGetSwapchainTimeDomainPropertiesEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			swapchain,
			p_swapchain_time_domain_properties,
			p_time_domains_counter,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetSwapchainTimeDomainPropertiesEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetSwapchainTimeDomainPropertiesEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetSwapchainTimeDomainPropertiesEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetSwapchainTimeDomainPropertiesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSwapchainTimeDomainPropertiesEXT.html)"]
	#[inline]
	pub unsafe fn get_swapchain_time_domain_properties_ext(
		&self,
		swapchain: vk::SwapchainKHR,
		p_swapchain_time_domain_properties: *mut vk::SwapchainTimeDomainPropertiesEXT<'_>,
		p_time_domains_counter: *mut u64,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_swapchain_time_domain_properties_ext(
				self,
				swapchain,
				p_swapchain_time_domain_properties,
				p_time_domains_counter,
			)
		}
	}
}

/// Call `vkGetPastPresentationTimingEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPastPresentationTimingEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPastPresentationTimingEXT")]
#[doc = "\n\n[Khronos reference: `vkGetPastPresentationTimingEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPastPresentationTimingEXT.html)"]
pub unsafe fn get_past_presentation_timing_ext(
	device: &Device,
	p_past_presentation_timing_info: *const vk::PastPresentationTimingInfoEXT<'_>,
	p_past_presentation_timing_properties: *mut vk::PastPresentationTimingPropertiesEXT<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_past_presentation_timing_ext
		.ok_or(CallError::MissingCommand("vkGetPastPresentationTimingEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_past_presentation_timing_info,
			p_past_presentation_timing_properties,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetPastPresentationTimingEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPastPresentationTimingEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPastPresentationTimingEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetPastPresentationTimingEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPastPresentationTimingEXT.html)"]
	#[inline]
	pub unsafe fn get_past_presentation_timing_ext(
		&self,
		p_past_presentation_timing_info: *const vk::PastPresentationTimingInfoEXT<'_>,
		p_past_presentation_timing_properties: *mut vk::PastPresentationTimingPropertiesEXT<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_past_presentation_timing_ext(
				self,
				p_past_presentation_timing_info,
				p_past_presentation_timing_properties,
			)
		}
	}
}

#[cfg(feature = "platform-screen")]
/// Call `vkGetScreenBufferPropertiesQNX` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetScreenBufferPropertiesQNX` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetScreenBufferPropertiesQNX")]
#[doc = "\n\n[Khronos reference: `vkGetScreenBufferPropertiesQNX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetScreenBufferPropertiesQNX.html)"]
pub unsafe fn get_screen_buffer_properties_qnx(
	device: &Device,
	buffer: *const vk::_screen_buffer,
	p_properties: *mut vk::ScreenBufferPropertiesQNX<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_screen_buffer_properties_qnx
		.ok_or(CallError::MissingCommand("vkGetScreenBufferPropertiesQNX"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), buffer, p_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-screen")]
impl Device {
	/// Call `vkGetScreenBufferPropertiesQNX` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetScreenBufferPropertiesQNX` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetScreenBufferPropertiesQNX")]
	#[doc = "\n\n[Khronos reference: `vkGetScreenBufferPropertiesQNX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetScreenBufferPropertiesQNX.html)"]
	#[inline]
	pub unsafe fn get_screen_buffer_properties_qnx(
		&self,
		buffer: *const vk::_screen_buffer,
		p_properties: *mut vk::ScreenBufferPropertiesQNX<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_screen_buffer_properties_qnx(self, buffer, p_properties) }
	}
}

/// Call `vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html)"]
pub unsafe fn get_physical_device_cooperative_matrix_properties_khr(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_property_count: *mut u32,
	p_properties: *mut vk::CooperativeMatrixPropertiesKHR<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_cooperative_matrix_properties_khr
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, p_property_count, p_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html)"]
	#[inline]
	pub unsafe fn get_physical_device_cooperative_matrix_properties_khr(
		&self,
		physical_device: vk::PhysicalDevice,
		p_property_count: *mut u32,
		p_properties: *mut vk::CooperativeMatrixPropertiesKHR<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_cooperative_matrix_properties_khr(
				self,
				physical_device,
				p_property_count,
				p_properties,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceCooperativeMatrixProperties2EXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceCooperativeMatrixProperties2EXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceCooperativeMatrixProperties2EXT")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceCooperativeMatrixProperties2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceCooperativeMatrixProperties2EXT.html)"]
pub unsafe fn get_physical_device_cooperative_matrix_properties2_ext(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_cooperative_matrix_info: *const vk::PhysicalDeviceCooperativeMatrixInfo2EXT<'_>,
	p_property_count: *mut u32,
	p_properties: *mut vk::CooperativeMatrixProperties2EXT<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_cooperative_matrix_properties2_ext
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceCooperativeMatrixProperties2EXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			physical_device,
			p_cooperative_matrix_info,
			p_property_count,
			p_properties,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceCooperativeMatrixProperties2EXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceCooperativeMatrixProperties2EXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceCooperativeMatrixProperties2EXT")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceCooperativeMatrixProperties2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceCooperativeMatrixProperties2EXT.html)"]
	#[inline]
	pub unsafe fn get_physical_device_cooperative_matrix_properties2_ext(
		&self,
		physical_device: vk::PhysicalDevice,
		p_cooperative_matrix_info: *const vk::PhysicalDeviceCooperativeMatrixInfo2EXT<'_>,
		p_property_count: *mut u32,
		p_properties: *mut vk::CooperativeMatrixProperties2EXT<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_cooperative_matrix_properties2_ext(
				self,
				physical_device,
				p_cooperative_matrix_info,
				p_property_count,
				p_properties,
			)
		}
	}
}

#[cfg(feature = "provisional")]
/// Call `vkGetExecutionGraphPipelineScratchSizeAMDX` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetExecutionGraphPipelineScratchSizeAMDX` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetExecutionGraphPipelineScratchSizeAMDX")]
#[doc = "\n\n[Khronos reference: `vkGetExecutionGraphPipelineScratchSizeAMDX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetExecutionGraphPipelineScratchSizeAMDX.html)"]
pub unsafe fn get_execution_graph_pipeline_scratch_size_amdx(
	device: &Device,
	execution_graph: vk::Pipeline,
	p_size_info: *mut vk::ExecutionGraphPipelineScratchSizeAMDX<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_execution_graph_pipeline_scratch_size_amdx
		.ok_or(CallError::MissingCommand(
			"vkGetExecutionGraphPipelineScratchSizeAMDX",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), execution_graph, p_size_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "provisional")]
impl Device {
	/// Call `vkGetExecutionGraphPipelineScratchSizeAMDX` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetExecutionGraphPipelineScratchSizeAMDX` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetExecutionGraphPipelineScratchSizeAMDX")]
	#[doc = "\n\n[Khronos reference: `vkGetExecutionGraphPipelineScratchSizeAMDX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetExecutionGraphPipelineScratchSizeAMDX.html)"]
	#[inline]
	pub unsafe fn get_execution_graph_pipeline_scratch_size_amdx(
		&self,
		execution_graph: vk::Pipeline,
		p_size_info: *mut vk::ExecutionGraphPipelineScratchSizeAMDX<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_execution_graph_pipeline_scratch_size_amdx(self, execution_graph, p_size_info) }
	}
}

#[cfg(feature = "provisional")]
/// Call `vkGetExecutionGraphPipelineNodeIndexAMDX` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetExecutionGraphPipelineNodeIndexAMDX` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetExecutionGraphPipelineNodeIndexAMDX")]
#[doc = "\n\n[Khronos reference: `vkGetExecutionGraphPipelineNodeIndexAMDX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetExecutionGraphPipelineNodeIndexAMDX.html)"]
pub unsafe fn get_execution_graph_pipeline_node_index_amdx(
	device: &Device,
	execution_graph: vk::Pipeline,
	p_node_info: *const vk::PipelineShaderStageNodeCreateInfoAMDX<'_>,
	p_node_index: *mut u32,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_execution_graph_pipeline_node_index_amdx
		.ok_or(CallError::MissingCommand(
			"vkGetExecutionGraphPipelineNodeIndexAMDX",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result =
		unsafe { __vk_function(device.handle(), execution_graph, p_node_info, p_node_index) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "provisional")]
impl Device {
	/// Call `vkGetExecutionGraphPipelineNodeIndexAMDX` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetExecutionGraphPipelineNodeIndexAMDX` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetExecutionGraphPipelineNodeIndexAMDX")]
	#[doc = "\n\n[Khronos reference: `vkGetExecutionGraphPipelineNodeIndexAMDX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetExecutionGraphPipelineNodeIndexAMDX.html)"]
	#[inline]
	pub unsafe fn get_execution_graph_pipeline_node_index_amdx(
		&self,
		execution_graph: vk::Pipeline,
		p_node_info: *const vk::PipelineShaderStageNodeCreateInfoAMDX<'_>,
		p_node_index: *mut u32,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_execution_graph_pipeline_node_index_amdx(self, execution_graph, p_node_info, p_node_index)
		}
	}
}

#[cfg(feature = "provisional")]
/// Call `vkCreateExecutionGraphPipelinesAMDX` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateExecutionGraphPipelinesAMDX` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateExecutionGraphPipelinesAMDX")]
#[doc = "\n\n[Khronos reference: `vkCreateExecutionGraphPipelinesAMDX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateExecutionGraphPipelinesAMDX.html)"]
pub unsafe fn create_execution_graph_pipelines_amdx(
	device: &Device,
	pipeline_cache: vk::PipelineCache,
	create_info_count: u32,
	p_create_infos: *const vk::ExecutionGraphPipelineCreateInfoAMDX<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_pipelines: *mut vk::Pipeline,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.create_execution_graph_pipelines_amdx
			.ok_or(CallError::MissingCommand(
				"vkCreateExecutionGraphPipelinesAMDX",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			pipeline_cache,
			create_info_count,
			p_create_infos,
			p_allocator,
			p_pipelines,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "provisional")]
impl Device {
	/// Call `vkCreateExecutionGraphPipelinesAMDX` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateExecutionGraphPipelinesAMDX` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateExecutionGraphPipelinesAMDX")]
	#[doc = "\n\n[Khronos reference: `vkCreateExecutionGraphPipelinesAMDX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateExecutionGraphPipelinesAMDX.html)"]
	#[inline]
	pub unsafe fn create_execution_graph_pipelines_amdx(
		&self,
		pipeline_cache: vk::PipelineCache,
		create_info_count: u32,
		p_create_infos: *const vk::ExecutionGraphPipelineCreateInfoAMDX<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_pipelines: *mut vk::Pipeline,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			create_execution_graph_pipelines_amdx(
				self,
				pipeline_cache,
				create_info_count,
				p_create_infos,
				p_allocator,
				p_pipelines,
			)
		}
	}
}

#[cfg(feature = "provisional")]
/// Call `vkCmdInitializeGraphScratchMemoryAMDX` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdInitializeGraphScratchMemoryAMDX` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdInitializeGraphScratchMemoryAMDX")]
#[doc = "\n\n[Khronos reference: `vkCmdInitializeGraphScratchMemoryAMDX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdInitializeGraphScratchMemoryAMDX.html)"]
pub unsafe fn cmd_initialize_graph_scratch_memory_amdx(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	execution_graph: vk::Pipeline,
	scratch: vk::DeviceAddress,
	scratch_size: vk::DeviceSize,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_initialize_graph_scratch_memory_amdx
			.ok_or(CallError::MissingCommand(
				"vkCmdInitializeGraphScratchMemoryAMDX",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, execution_graph, scratch, scratch_size) };
	Ok(())
}

#[cfg(feature = "provisional")]
impl Device {
	/// Call `vkCmdInitializeGraphScratchMemoryAMDX` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdInitializeGraphScratchMemoryAMDX` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdInitializeGraphScratchMemoryAMDX")]
	#[doc = "\n\n[Khronos reference: `vkCmdInitializeGraphScratchMemoryAMDX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdInitializeGraphScratchMemoryAMDX.html)"]
	#[inline]
	pub unsafe fn cmd_initialize_graph_scratch_memory_amdx(
		&self,
		command_buffer: vk::CommandBuffer,
		execution_graph: vk::Pipeline,
		scratch: vk::DeviceAddress,
		scratch_size: vk::DeviceSize,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_initialize_graph_scratch_memory_amdx(
				self,
				command_buffer,
				execution_graph,
				scratch,
				scratch_size,
			)
		}
	}
}

#[cfg(feature = "provisional")]
/// Call `vkCmdDispatchGraphAMDX` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDispatchGraphAMDX` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDispatchGraphAMDX")]
#[doc = "\n\n[Khronos reference: `vkCmdDispatchGraphAMDX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDispatchGraphAMDX.html)"]
pub unsafe fn cmd_dispatch_graph_amdx(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	scratch: vk::DeviceAddress,
	scratch_size: vk::DeviceSize,
	p_count_info: *const vk::DispatchGraphCountInfoAMDX,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_dispatch_graph_amdx
		.ok_or(CallError::MissingCommand("vkCmdDispatchGraphAMDX"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, scratch, scratch_size, p_count_info) };
	Ok(())
}

#[cfg(feature = "provisional")]
impl Device {
	/// Call `vkCmdDispatchGraphAMDX` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDispatchGraphAMDX` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDispatchGraphAMDX")]
	#[doc = "\n\n[Khronos reference: `vkCmdDispatchGraphAMDX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDispatchGraphAMDX.html)"]
	#[inline]
	pub unsafe fn cmd_dispatch_graph_amdx(
		&self,
		command_buffer: vk::CommandBuffer,
		scratch: vk::DeviceAddress,
		scratch_size: vk::DeviceSize,
		p_count_info: *const vk::DispatchGraphCountInfoAMDX,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_dispatch_graph_amdx(self, command_buffer, scratch, scratch_size, p_count_info) }
	}
}

#[cfg(feature = "provisional")]
/// Call `vkCmdDispatchGraphIndirectAMDX` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDispatchGraphIndirectAMDX` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDispatchGraphIndirectAMDX")]
#[doc = "\n\n[Khronos reference: `vkCmdDispatchGraphIndirectAMDX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDispatchGraphIndirectAMDX.html)"]
pub unsafe fn cmd_dispatch_graph_indirect_amdx(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	scratch: vk::DeviceAddress,
	scratch_size: vk::DeviceSize,
	p_count_info: *const vk::DispatchGraphCountInfoAMDX,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_dispatch_graph_indirect_amdx
		.ok_or(CallError::MissingCommand("vkCmdDispatchGraphIndirectAMDX"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, scratch, scratch_size, p_count_info) };
	Ok(())
}

#[cfg(feature = "provisional")]
impl Device {
	/// Call `vkCmdDispatchGraphIndirectAMDX` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDispatchGraphIndirectAMDX` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDispatchGraphIndirectAMDX")]
	#[doc = "\n\n[Khronos reference: `vkCmdDispatchGraphIndirectAMDX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDispatchGraphIndirectAMDX.html)"]
	#[inline]
	pub unsafe fn cmd_dispatch_graph_indirect_amdx(
		&self,
		command_buffer: vk::CommandBuffer,
		scratch: vk::DeviceAddress,
		scratch_size: vk::DeviceSize,
		p_count_info: *const vk::DispatchGraphCountInfoAMDX,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_dispatch_graph_indirect_amdx(self, command_buffer, scratch, scratch_size, p_count_info)
		}
	}
}

#[cfg(feature = "provisional")]
/// Call `vkCmdDispatchGraphIndirectCountAMDX` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDispatchGraphIndirectCountAMDX` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDispatchGraphIndirectCountAMDX")]
#[doc = "\n\n[Khronos reference: `vkCmdDispatchGraphIndirectCountAMDX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDispatchGraphIndirectCountAMDX.html)"]
pub unsafe fn cmd_dispatch_graph_indirect_count_amdx(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	scratch: vk::DeviceAddress,
	scratch_size: vk::DeviceSize,
	count_info: vk::DeviceAddress,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_dispatch_graph_indirect_count_amdx
			.ok_or(CallError::MissingCommand(
				"vkCmdDispatchGraphIndirectCountAMDX",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, scratch, scratch_size, count_info) };
	Ok(())
}

#[cfg(feature = "provisional")]
impl Device {
	/// Call `vkCmdDispatchGraphIndirectCountAMDX` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDispatchGraphIndirectCountAMDX` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDispatchGraphIndirectCountAMDX")]
	#[doc = "\n\n[Khronos reference: `vkCmdDispatchGraphIndirectCountAMDX`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDispatchGraphIndirectCountAMDX.html)"]
	#[inline]
	pub unsafe fn cmd_dispatch_graph_indirect_count_amdx(
		&self,
		command_buffer: vk::CommandBuffer,
		scratch: vk::DeviceAddress,
		scratch_size: vk::DeviceSize,
		count_info: vk::DeviceAddress,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_dispatch_graph_indirect_count_amdx(
				self,
				command_buffer,
				scratch,
				scratch_size,
				count_info,
			)
		}
	}
}

/// Call `vkCreateGpaSessionAMD` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateGpaSessionAMD` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateGpaSessionAMD")]
#[doc = "\n\n[Khronos reference: `vkCreateGpaSessionAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateGpaSessionAMD.html)"]
pub unsafe fn create_gpa_session_amd(
	device: &Device,
	p_create_info: *const vk::GpaSessionCreateInfoAMD<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_gpa_session: *mut vk::GpaSessionAMD,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_gpa_session_amd
		.ok_or(CallError::MissingCommand("vkCreateGpaSessionAMD"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_create_info, p_allocator, p_gpa_session) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateGpaSessionAMD` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateGpaSessionAMD` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateGpaSessionAMD")]
	#[doc = "\n\n[Khronos reference: `vkCreateGpaSessionAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateGpaSessionAMD.html)"]
	#[inline]
	pub unsafe fn create_gpa_session_amd(
		&self,
		p_create_info: *const vk::GpaSessionCreateInfoAMD<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_gpa_session: *mut vk::GpaSessionAMD,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_gpa_session_amd(self, p_create_info, p_allocator, p_gpa_session) }
	}
}

/// Call `vkDestroyGpaSessionAMD` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyGpaSessionAMD` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyGpaSessionAMD")]
#[doc = "\n\n[Khronos reference: `vkDestroyGpaSessionAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyGpaSessionAMD.html)"]
pub unsafe fn destroy_gpa_session_amd(
	device: &Device,
	gpa_session: vk::GpaSessionAMD,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_gpa_session_amd
		.ok_or(CallError::MissingCommand("vkDestroyGpaSessionAMD"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), gpa_session, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyGpaSessionAMD` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyGpaSessionAMD` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyGpaSessionAMD")]
	#[doc = "\n\n[Khronos reference: `vkDestroyGpaSessionAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyGpaSessionAMD.html)"]
	#[inline]
	pub unsafe fn destroy_gpa_session_amd(
		&self,
		gpa_session: vk::GpaSessionAMD,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_gpa_session_amd(self, gpa_session, p_allocator) }
	}
}

/// Call `vkSetGpaDeviceClockModeAMD` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkSetGpaDeviceClockModeAMD` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkSetGpaDeviceClockModeAMD")]
#[doc = "\n\n[Khronos reference: `vkSetGpaDeviceClockModeAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetGpaDeviceClockModeAMD.html)"]
pub unsafe fn set_gpa_device_clock_mode_amd(
	device: &Device,
	p_info: *mut vk::GpaDeviceClockModeInfoAMD<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.set_gpa_device_clock_mode_amd
		.ok_or(CallError::MissingCommand("vkSetGpaDeviceClockModeAMD"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkSetGpaDeviceClockModeAMD` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkSetGpaDeviceClockModeAMD` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkSetGpaDeviceClockModeAMD")]
	#[doc = "\n\n[Khronos reference: `vkSetGpaDeviceClockModeAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetGpaDeviceClockModeAMD.html)"]
	#[inline]
	pub unsafe fn set_gpa_device_clock_mode_amd(
		&self,
		p_info: *mut vk::GpaDeviceClockModeInfoAMD<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { set_gpa_device_clock_mode_amd(self, p_info) }
	}
}

/// Call `vkGetGpaDeviceClockInfoAMD` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetGpaDeviceClockInfoAMD` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetGpaDeviceClockInfoAMD")]
#[doc = "\n\n[Khronos reference: `vkGetGpaDeviceClockInfoAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetGpaDeviceClockInfoAMD.html)"]
pub unsafe fn get_gpa_device_clock_info_amd(
	device: &Device,
	p_info: *mut vk::GpaDeviceGetClockInfoAMD<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_gpa_device_clock_info_amd
		.ok_or(CallError::MissingCommand("vkGetGpaDeviceClockInfoAMD"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetGpaDeviceClockInfoAMD` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetGpaDeviceClockInfoAMD` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetGpaDeviceClockInfoAMD")]
	#[doc = "\n\n[Khronos reference: `vkGetGpaDeviceClockInfoAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetGpaDeviceClockInfoAMD.html)"]
	#[inline]
	pub unsafe fn get_gpa_device_clock_info_amd(
		&self,
		p_info: *mut vk::GpaDeviceGetClockInfoAMD<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_gpa_device_clock_info_amd(self, p_info) }
	}
}

/// Call `vkCmdBeginGpaSessionAMD` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBeginGpaSessionAMD` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBeginGpaSessionAMD")]
#[doc = "\n\n[Khronos reference: `vkCmdBeginGpaSessionAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginGpaSessionAMD.html)"]
pub unsafe fn cmd_begin_gpa_session_amd(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	gpa_session: vk::GpaSessionAMD,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.cmd_begin_gpa_session_amd
		.ok_or(CallError::MissingCommand("vkCmdBeginGpaSessionAMD"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(command_buffer, gpa_session) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCmdBeginGpaSessionAMD` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBeginGpaSessionAMD` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBeginGpaSessionAMD")]
	#[doc = "\n\n[Khronos reference: `vkCmdBeginGpaSessionAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginGpaSessionAMD.html)"]
	#[inline]
	pub unsafe fn cmd_begin_gpa_session_amd(
		&self,
		command_buffer: vk::CommandBuffer,
		gpa_session: vk::GpaSessionAMD,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_begin_gpa_session_amd(self, command_buffer, gpa_session) }
	}
}

/// Call `vkCmdEndGpaSessionAMD` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdEndGpaSessionAMD` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdEndGpaSessionAMD")]
#[doc = "\n\n[Khronos reference: `vkCmdEndGpaSessionAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndGpaSessionAMD.html)"]
pub unsafe fn cmd_end_gpa_session_amd(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	gpa_session: vk::GpaSessionAMD,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.cmd_end_gpa_session_amd
		.ok_or(CallError::MissingCommand("vkCmdEndGpaSessionAMD"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(command_buffer, gpa_session) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCmdEndGpaSessionAMD` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdEndGpaSessionAMD` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdEndGpaSessionAMD")]
	#[doc = "\n\n[Khronos reference: `vkCmdEndGpaSessionAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndGpaSessionAMD.html)"]
	#[inline]
	pub unsafe fn cmd_end_gpa_session_amd(
		&self,
		command_buffer: vk::CommandBuffer,
		gpa_session: vk::GpaSessionAMD,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_end_gpa_session_amd(self, command_buffer, gpa_session) }
	}
}

/// Call `vkCmdBeginGpaSampleAMD` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBeginGpaSampleAMD` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBeginGpaSampleAMD")]
#[doc = "\n\n[Khronos reference: `vkCmdBeginGpaSampleAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginGpaSampleAMD.html)"]
pub unsafe fn cmd_begin_gpa_sample_amd(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	gpa_session: vk::GpaSessionAMD,
	p_gpa_sample_begin_info: *const vk::GpaSampleBeginInfoAMD<'_>,
	p_sample_id: *mut u32,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.cmd_begin_gpa_sample_amd
		.ok_or(CallError::MissingCommand("vkCmdBeginGpaSampleAMD"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			command_buffer,
			gpa_session,
			p_gpa_sample_begin_info,
			p_sample_id,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCmdBeginGpaSampleAMD` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBeginGpaSampleAMD` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBeginGpaSampleAMD")]
	#[doc = "\n\n[Khronos reference: `vkCmdBeginGpaSampleAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginGpaSampleAMD.html)"]
	#[inline]
	pub unsafe fn cmd_begin_gpa_sample_amd(
		&self,
		command_buffer: vk::CommandBuffer,
		gpa_session: vk::GpaSessionAMD,
		p_gpa_sample_begin_info: *const vk::GpaSampleBeginInfoAMD<'_>,
		p_sample_id: *mut u32,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_begin_gpa_sample_amd(
				self,
				command_buffer,
				gpa_session,
				p_gpa_sample_begin_info,
				p_sample_id,
			)
		}
	}
}

/// Call `vkCmdEndGpaSampleAMD` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdEndGpaSampleAMD` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdEndGpaSampleAMD")]
#[doc = "\n\n[Khronos reference: `vkCmdEndGpaSampleAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndGpaSampleAMD.html)"]
pub unsafe fn cmd_end_gpa_sample_amd(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	gpa_session: vk::GpaSessionAMD,
	sample_id: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_end_gpa_sample_amd
		.ok_or(CallError::MissingCommand("vkCmdEndGpaSampleAMD"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, gpa_session, sample_id) };
	Ok(())
}

impl Device {
	/// Call `vkCmdEndGpaSampleAMD` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdEndGpaSampleAMD` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdEndGpaSampleAMD")]
	#[doc = "\n\n[Khronos reference: `vkCmdEndGpaSampleAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndGpaSampleAMD.html)"]
	#[inline]
	pub unsafe fn cmd_end_gpa_sample_amd(
		&self,
		command_buffer: vk::CommandBuffer,
		gpa_session: vk::GpaSessionAMD,
		sample_id: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_end_gpa_sample_amd(self, command_buffer, gpa_session, sample_id) }
	}
}

/// Call `vkGetGpaSessionStatusAMD` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetGpaSessionStatusAMD` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetGpaSessionStatusAMD")]
#[doc = "\n\n[Khronos reference: `vkGetGpaSessionStatusAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetGpaSessionStatusAMD.html)"]
pub unsafe fn get_gpa_session_status_amd(
	device: &Device,
	gpa_session: vk::GpaSessionAMD,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_gpa_session_status_amd
		.ok_or(CallError::MissingCommand("vkGetGpaSessionStatusAMD"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), gpa_session) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetGpaSessionStatusAMD` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetGpaSessionStatusAMD` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetGpaSessionStatusAMD")]
	#[doc = "\n\n[Khronos reference: `vkGetGpaSessionStatusAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetGpaSessionStatusAMD.html)"]
	#[inline]
	pub unsafe fn get_gpa_session_status_amd(
		&self,
		gpa_session: vk::GpaSessionAMD,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_gpa_session_status_amd(self, gpa_session) }
	}
}

/// Call `vkGetGpaSessionResultsAMD` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetGpaSessionResultsAMD` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetGpaSessionResultsAMD")]
#[doc = "\n\n[Khronos reference: `vkGetGpaSessionResultsAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetGpaSessionResultsAMD.html)"]
pub unsafe fn get_gpa_session_results_amd(
	device: &Device,
	gpa_session: vk::GpaSessionAMD,
	sample_id: u32,
	p_size_in_bytes: *mut usize,
	p_data: *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_gpa_session_results_amd
		.ok_or(CallError::MissingCommand("vkGetGpaSessionResultsAMD"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			gpa_session,
			sample_id,
			p_size_in_bytes,
			p_data,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetGpaSessionResultsAMD` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetGpaSessionResultsAMD` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetGpaSessionResultsAMD")]
	#[doc = "\n\n[Khronos reference: `vkGetGpaSessionResultsAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetGpaSessionResultsAMD.html)"]
	#[inline]
	pub unsafe fn get_gpa_session_results_amd(
		&self,
		gpa_session: vk::GpaSessionAMD,
		sample_id: u32,
		p_size_in_bytes: *mut usize,
		p_data: *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_gpa_session_results_amd(self, gpa_session, sample_id, p_size_in_bytes, p_data) }
	}
}

/// Call `vkResetGpaSessionAMD` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkResetGpaSessionAMD` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkResetGpaSessionAMD")]
#[doc = "\n\n[Khronos reference: `vkResetGpaSessionAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkResetGpaSessionAMD.html)"]
pub unsafe fn reset_gpa_session_amd(
	device: &Device,
	gpa_session: vk::GpaSessionAMD,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.reset_gpa_session_amd
		.ok_or(CallError::MissingCommand("vkResetGpaSessionAMD"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), gpa_session) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkResetGpaSessionAMD` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkResetGpaSessionAMD` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkResetGpaSessionAMD")]
	#[doc = "\n\n[Khronos reference: `vkResetGpaSessionAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkResetGpaSessionAMD.html)"]
	#[inline]
	pub unsafe fn reset_gpa_session_amd(
		&self,
		gpa_session: vk::GpaSessionAMD,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { reset_gpa_session_amd(self, gpa_session) }
	}
}

/// Call `vkCmdCopyGpaSessionResultsAMD` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyGpaSessionResultsAMD` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdCopyGpaSessionResultsAMD")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyGpaSessionResultsAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyGpaSessionResultsAMD.html)"]
pub unsafe fn cmd_copy_gpa_session_results_amd(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	gpa_session: vk::GpaSessionAMD,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_gpa_session_results_amd
		.ok_or(CallError::MissingCommand("vkCmdCopyGpaSessionResultsAMD"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, gpa_session) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyGpaSessionResultsAMD` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyGpaSessionResultsAMD` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdCopyGpaSessionResultsAMD")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyGpaSessionResultsAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyGpaSessionResultsAMD.html)"]
	#[inline]
	pub unsafe fn cmd_copy_gpa_session_results_amd(
		&self,
		command_buffer: vk::CommandBuffer,
		gpa_session: vk::GpaSessionAMD,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_gpa_session_results_amd(self, command_buffer, gpa_session) }
	}
}

/// Call `vkCmdBindDescriptorSets2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindDescriptorSets2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBindDescriptorSets2")]
#[doc = "\n\n[Khronos reference: `vkCmdBindDescriptorSets2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindDescriptorSets2.html)"]
pub unsafe fn cmd_bind_descriptor_sets2(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_bind_descriptor_sets_info: *const vk::BindDescriptorSetsInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_descriptor_sets2
		.ok_or(CallError::MissingCommand("vkCmdBindDescriptorSets2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_bind_descriptor_sets_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBindDescriptorSets2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindDescriptorSets2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBindDescriptorSets2")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindDescriptorSets2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindDescriptorSets2.html)"]
	#[inline]
	pub unsafe fn cmd_bind_descriptor_sets2(
		&self,
		command_buffer: vk::CommandBuffer,
		p_bind_descriptor_sets_info: *const vk::BindDescriptorSetsInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_bind_descriptor_sets2(self, command_buffer, p_bind_descriptor_sets_info) }
	}
}

/// Call `vkCmdBindDescriptorSets2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindDescriptorSets2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBindDescriptorSets2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdBindDescriptorSets2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindDescriptorSets2KHR.html)"]
pub unsafe fn cmd_bind_descriptor_sets2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_bind_descriptor_sets_info: *const vk::BindDescriptorSetsInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_descriptor_sets2_khr
		.ok_or(CallError::MissingCommand("vkCmdBindDescriptorSets2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_bind_descriptor_sets_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBindDescriptorSets2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindDescriptorSets2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBindDescriptorSets2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindDescriptorSets2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindDescriptorSets2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_bind_descriptor_sets2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_bind_descriptor_sets_info: *const vk::BindDescriptorSetsInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_bind_descriptor_sets2_khr(self, command_buffer, p_bind_descriptor_sets_info) }
	}
}

/// Call `vkCmdPushConstants2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdPushConstants2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdPushConstants2")]
#[doc = "\n\n[Khronos reference: `vkCmdPushConstants2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushConstants2.html)"]
pub unsafe fn cmd_push_constants2(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_push_constants_info: *const vk::PushConstantsInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_push_constants2
		.ok_or(CallError::MissingCommand("vkCmdPushConstants2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_push_constants_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdPushConstants2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdPushConstants2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdPushConstants2")]
	#[doc = "\n\n[Khronos reference: `vkCmdPushConstants2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushConstants2.html)"]
	#[inline]
	pub unsafe fn cmd_push_constants2(
		&self,
		command_buffer: vk::CommandBuffer,
		p_push_constants_info: *const vk::PushConstantsInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_push_constants2(self, command_buffer, p_push_constants_info) }
	}
}

/// Call `vkCmdPushConstants2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdPushConstants2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdPushConstants2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdPushConstants2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushConstants2KHR.html)"]
pub unsafe fn cmd_push_constants2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_push_constants_info: *const vk::PushConstantsInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_push_constants2_khr
		.ok_or(CallError::MissingCommand("vkCmdPushConstants2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_push_constants_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdPushConstants2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdPushConstants2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdPushConstants2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdPushConstants2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushConstants2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_push_constants2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_push_constants_info: *const vk::PushConstantsInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_push_constants2_khr(self, command_buffer, p_push_constants_info) }
	}
}

/// Call `vkCmdPushDescriptorSet2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdPushDescriptorSet2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdPushDescriptorSet2")]
#[doc = "\n\n[Khronos reference: `vkCmdPushDescriptorSet2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushDescriptorSet2.html)"]
pub unsafe fn cmd_push_descriptor_set2(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_push_descriptor_set_info: *const vk::PushDescriptorSetInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_push_descriptor_set2
		.ok_or(CallError::MissingCommand("vkCmdPushDescriptorSet2"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_push_descriptor_set_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdPushDescriptorSet2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdPushDescriptorSet2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdPushDescriptorSet2")]
	#[doc = "\n\n[Khronos reference: `vkCmdPushDescriptorSet2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushDescriptorSet2.html)"]
	#[inline]
	pub unsafe fn cmd_push_descriptor_set2(
		&self,
		command_buffer: vk::CommandBuffer,
		p_push_descriptor_set_info: *const vk::PushDescriptorSetInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_push_descriptor_set2(self, command_buffer, p_push_descriptor_set_info) }
	}
}

/// Call `vkCmdPushDescriptorSet2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdPushDescriptorSet2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdPushDescriptorSet2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdPushDescriptorSet2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushDescriptorSet2KHR.html)"]
pub unsafe fn cmd_push_descriptor_set2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_push_descriptor_set_info: *const vk::PushDescriptorSetInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_push_descriptor_set2_khr
		.ok_or(CallError::MissingCommand("vkCmdPushDescriptorSet2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_push_descriptor_set_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdPushDescriptorSet2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdPushDescriptorSet2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdPushDescriptorSet2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdPushDescriptorSet2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushDescriptorSet2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_push_descriptor_set2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_push_descriptor_set_info: *const vk::PushDescriptorSetInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_push_descriptor_set2_khr(self, command_buffer, p_push_descriptor_set_info) }
	}
}

/// Call `vkCmdPushDescriptorSetWithTemplate2` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdPushDescriptorSetWithTemplate2` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdPushDescriptorSetWithTemplate2")]
#[doc = "\n\n[Khronos reference: `vkCmdPushDescriptorSetWithTemplate2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushDescriptorSetWithTemplate2.html)"]
pub unsafe fn cmd_push_descriptor_set_with_template2(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_push_descriptor_set_with_template_info: *const vk::PushDescriptorSetWithTemplateInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_push_descriptor_set_with_template2
			.ok_or(CallError::MissingCommand(
				"vkCmdPushDescriptorSetWithTemplate2",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_push_descriptor_set_with_template_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdPushDescriptorSetWithTemplate2` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdPushDescriptorSetWithTemplate2` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdPushDescriptorSetWithTemplate2")]
	#[doc = "\n\n[Khronos reference: `vkCmdPushDescriptorSetWithTemplate2`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushDescriptorSetWithTemplate2.html)"]
	#[inline]
	pub unsafe fn cmd_push_descriptor_set_with_template2(
		&self,
		command_buffer: vk::CommandBuffer,
		p_push_descriptor_set_with_template_info: *const vk::PushDescriptorSetWithTemplateInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_push_descriptor_set_with_template2(
				self,
				command_buffer,
				p_push_descriptor_set_with_template_info,
			)
		}
	}
}

/// Call `vkCmdPushDescriptorSetWithTemplate2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdPushDescriptorSetWithTemplate2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdPushDescriptorSetWithTemplate2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdPushDescriptorSetWithTemplate2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushDescriptorSetWithTemplate2KHR.html)"]
pub unsafe fn cmd_push_descriptor_set_with_template2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_push_descriptor_set_with_template_info: *const vk::PushDescriptorSetWithTemplateInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_push_descriptor_set_with_template2_khr
		.ok_or(CallError::MissingCommand(
			"vkCmdPushDescriptorSetWithTemplate2KHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_push_descriptor_set_with_template_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdPushDescriptorSetWithTemplate2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdPushDescriptorSetWithTemplate2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdPushDescriptorSetWithTemplate2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdPushDescriptorSetWithTemplate2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushDescriptorSetWithTemplate2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_push_descriptor_set_with_template2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_push_descriptor_set_with_template_info: *const vk::PushDescriptorSetWithTemplateInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_push_descriptor_set_with_template2_khr(
				self,
				command_buffer,
				p_push_descriptor_set_with_template_info,
			)
		}
	}
}

/// Call `vkCmdSetDescriptorBufferOffsets2EXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDescriptorBufferOffsets2EXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDescriptorBufferOffsets2EXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDescriptorBufferOffsets2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDescriptorBufferOffsets2EXT.html)"]
pub unsafe fn cmd_set_descriptor_buffer_offsets2_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_set_descriptor_buffer_offsets_info: *const vk::SetDescriptorBufferOffsetsInfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_descriptor_buffer_offsets2_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdSetDescriptorBufferOffsets2EXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_set_descriptor_buffer_offsets_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDescriptorBufferOffsets2EXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDescriptorBufferOffsets2EXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDescriptorBufferOffsets2EXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDescriptorBufferOffsets2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDescriptorBufferOffsets2EXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_descriptor_buffer_offsets2_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_set_descriptor_buffer_offsets_info: *const vk::SetDescriptorBufferOffsetsInfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_descriptor_buffer_offsets2_ext(
				self,
				command_buffer,
				p_set_descriptor_buffer_offsets_info,
			)
		}
	}
}

/// Call `vkCmdBindDescriptorBufferEmbeddedSamplers2EXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindDescriptorBufferEmbeddedSamplers2EXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT")]
#[doc = "\n\n[Khronos reference: `vkCmdBindDescriptorBufferEmbeddedSamplers2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html)"]
pub unsafe fn cmd_bind_descriptor_buffer_embedded_samplers2_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_bind_descriptor_buffer_embedded_samplers_info: *const vk::BindDescriptorBufferEmbeddedSamplersInfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_descriptor_buffer_embedded_samplers2_ext
		.ok_or(CallError::MissingCommand(
			"vkCmdBindDescriptorBufferEmbeddedSamplers2EXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			p_bind_descriptor_buffer_embedded_samplers_info,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdBindDescriptorBufferEmbeddedSamplers2EXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindDescriptorBufferEmbeddedSamplers2EXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindDescriptorBufferEmbeddedSamplers2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html)"]
	#[inline]
	pub unsafe fn cmd_bind_descriptor_buffer_embedded_samplers2_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_bind_descriptor_buffer_embedded_samplers_info: *const vk::BindDescriptorBufferEmbeddedSamplersInfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_bind_descriptor_buffer_embedded_samplers2_ext(
				self,
				command_buffer,
				p_bind_descriptor_buffer_embedded_samplers_info,
			)
		}
	}
}

/// Call `vkSetLatencySleepModeNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkSetLatencySleepModeNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkSetLatencySleepModeNV")]
#[doc = "\n\n[Khronos reference: `vkSetLatencySleepModeNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetLatencySleepModeNV.html)"]
pub unsafe fn set_latency_sleep_mode_nv(
	device: &Device,
	swapchain: vk::SwapchainKHR,
	p_sleep_mode_info: *const vk::LatencySleepModeInfoNV<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.set_latency_sleep_mode_nv
		.ok_or(CallError::MissingCommand("vkSetLatencySleepModeNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), swapchain, p_sleep_mode_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkSetLatencySleepModeNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkSetLatencySleepModeNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkSetLatencySleepModeNV")]
	#[doc = "\n\n[Khronos reference: `vkSetLatencySleepModeNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetLatencySleepModeNV.html)"]
	#[inline]
	pub unsafe fn set_latency_sleep_mode_nv(
		&self,
		swapchain: vk::SwapchainKHR,
		p_sleep_mode_info: *const vk::LatencySleepModeInfoNV<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { set_latency_sleep_mode_nv(self, swapchain, p_sleep_mode_info) }
	}
}

/// Call `vkLatencySleepNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkLatencySleepNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkLatencySleepNV")]
#[doc = "\n\n[Khronos reference: `vkLatencySleepNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkLatencySleepNV.html)"]
pub unsafe fn latency_sleep_nv(
	device: &Device,
	swapchain: vk::SwapchainKHR,
	p_sleep_info: *const vk::LatencySleepInfoNV<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.latency_sleep_nv
		.ok_or(CallError::MissingCommand("vkLatencySleepNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), swapchain, p_sleep_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkLatencySleepNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkLatencySleepNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkLatencySleepNV")]
	#[doc = "\n\n[Khronos reference: `vkLatencySleepNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkLatencySleepNV.html)"]
	#[inline]
	pub unsafe fn latency_sleep_nv(
		&self,
		swapchain: vk::SwapchainKHR,
		p_sleep_info: *const vk::LatencySleepInfoNV<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { latency_sleep_nv(self, swapchain, p_sleep_info) }
	}
}

/// Call `vkSetLatencyMarkerNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkSetLatencyMarkerNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkSetLatencyMarkerNV")]
#[doc = "\n\n[Khronos reference: `vkSetLatencyMarkerNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetLatencyMarkerNV.html)"]
pub unsafe fn set_latency_marker_nv(
	device: &Device,
	swapchain: vk::SwapchainKHR,
	p_latency_marker_info: *const vk::SetLatencyMarkerInfoNV<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.set_latency_marker_nv
		.ok_or(CallError::MissingCommand("vkSetLatencyMarkerNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), swapchain, p_latency_marker_info) };
	Ok(())
}

impl Device {
	/// Call `vkSetLatencyMarkerNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkSetLatencyMarkerNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkSetLatencyMarkerNV")]
	#[doc = "\n\n[Khronos reference: `vkSetLatencyMarkerNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetLatencyMarkerNV.html)"]
	#[inline]
	pub unsafe fn set_latency_marker_nv(
		&self,
		swapchain: vk::SwapchainKHR,
		p_latency_marker_info: *const vk::SetLatencyMarkerInfoNV<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { set_latency_marker_nv(self, swapchain, p_latency_marker_info) }
	}
}

/// Call `vkGetLatencyTimingsNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetLatencyTimingsNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetLatencyTimingsNV")]
#[doc = "\n\n[Khronos reference: `vkGetLatencyTimingsNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetLatencyTimingsNV.html)"]
pub unsafe fn get_latency_timings_nv(
	device: &Device,
	swapchain: vk::SwapchainKHR,
	p_latency_marker_info: *mut vk::GetLatencyMarkerInfoNV<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_latency_timings_nv
		.ok_or(CallError::MissingCommand("vkGetLatencyTimingsNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), swapchain, p_latency_marker_info) };
	Ok(())
}

impl Device {
	/// Call `vkGetLatencyTimingsNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetLatencyTimingsNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetLatencyTimingsNV")]
	#[doc = "\n\n[Khronos reference: `vkGetLatencyTimingsNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetLatencyTimingsNV.html)"]
	#[inline]
	pub unsafe fn get_latency_timings_nv(
		&self,
		swapchain: vk::SwapchainKHR,
		p_latency_marker_info: *mut vk::GetLatencyMarkerInfoNV<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_latency_timings_nv(self, swapchain, p_latency_marker_info) }
	}
}

/// Call `vkQueueNotifyOutOfBandNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkQueueNotifyOutOfBandNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkQueueNotifyOutOfBandNV")]
#[doc = "\n\n[Khronos reference: `vkQueueNotifyOutOfBandNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueueNotifyOutOfBandNV.html)"]
pub unsafe fn queue_notify_out_of_band_nv(
	device: &Device,
	queue: vk::Queue,
	p_queue_type_info: *const vk::OutOfBandQueueTypeInfoNV<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.queue_notify_out_of_band_nv
		.ok_or(CallError::MissingCommand("vkQueueNotifyOutOfBandNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(queue, p_queue_type_info) };
	Ok(())
}

impl Device {
	/// Call `vkQueueNotifyOutOfBandNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkQueueNotifyOutOfBandNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkQueueNotifyOutOfBandNV")]
	#[doc = "\n\n[Khronos reference: `vkQueueNotifyOutOfBandNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueueNotifyOutOfBandNV.html)"]
	#[inline]
	pub unsafe fn queue_notify_out_of_band_nv(
		&self,
		queue: vk::Queue,
		p_queue_type_info: *const vk::OutOfBandQueueTypeInfoNV<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { queue_notify_out_of_band_nv(self, queue, p_queue_type_info) }
	}
}

/// Call `vkSetLatencySleepModeLegacyNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkSetLatencySleepModeLegacyNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkSetLatencySleepModeLegacyNV")]
#[doc = "\n\n[Khronos reference: `vkSetLatencySleepModeLegacyNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetLatencySleepModeLegacyNV.html)"]
pub unsafe fn set_latency_sleep_mode_legacy_nv(
	device: &Device,
	low_latency_mode: vk::Bool32,
	low_latency_boost: vk::Bool32,
	minimum_interval_us: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.set_latency_sleep_mode_legacy_nv
		.ok_or(CallError::MissingCommand("vkSetLatencySleepModeLegacyNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			device.handle(),
			low_latency_mode,
			low_latency_boost,
			minimum_interval_us,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkSetLatencySleepModeLegacyNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkSetLatencySleepModeLegacyNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkSetLatencySleepModeLegacyNV")]
	#[doc = "\n\n[Khronos reference: `vkSetLatencySleepModeLegacyNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetLatencySleepModeLegacyNV.html)"]
	#[inline]
	pub unsafe fn set_latency_sleep_mode_legacy_nv(
		&self,
		low_latency_mode: vk::Bool32,
		low_latency_boost: vk::Bool32,
		minimum_interval_us: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			set_latency_sleep_mode_legacy_nv(
				self,
				low_latency_mode,
				low_latency_boost,
				minimum_interval_us,
			)
		}
	}
}

/// Call `vkLatencySleepLegacyNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkLatencySleepLegacyNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkLatencySleepLegacyNV")]
#[doc = "\n\n[Khronos reference: `vkLatencySleepLegacyNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkLatencySleepLegacyNV.html)"]
pub unsafe fn latency_sleep_legacy_nv(
	device: &Device,
	signal_semaphore: vk::Semaphore,
	value: u64,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.latency_sleep_legacy_nv
		.ok_or(CallError::MissingCommand("vkLatencySleepLegacyNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), signal_semaphore, value) };
	Ok(())
}

impl Device {
	/// Call `vkLatencySleepLegacyNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkLatencySleepLegacyNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkLatencySleepLegacyNV")]
	#[doc = "\n\n[Khronos reference: `vkLatencySleepLegacyNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkLatencySleepLegacyNV.html)"]
	#[inline]
	pub unsafe fn latency_sleep_legacy_nv(
		&self,
		signal_semaphore: vk::Semaphore,
		value: u64,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { latency_sleep_legacy_nv(self, signal_semaphore, value) }
	}
}

/// Call `vkSetLatencyMarkerLegacyNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkSetLatencyMarkerLegacyNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkSetLatencyMarkerLegacyNV")]
#[doc = "\n\n[Khronos reference: `vkSetLatencyMarkerLegacyNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetLatencyMarkerLegacyNV.html)"]
pub unsafe fn set_latency_marker_legacy_nv(
	device: &Device,
	frame_id: u64,
	marker: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.set_latency_marker_legacy_nv
		.ok_or(CallError::MissingCommand("vkSetLatencyMarkerLegacyNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), frame_id, marker) };
	Ok(())
}

impl Device {
	/// Call `vkSetLatencyMarkerLegacyNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkSetLatencyMarkerLegacyNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkSetLatencyMarkerLegacyNV")]
	#[doc = "\n\n[Khronos reference: `vkSetLatencyMarkerLegacyNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkSetLatencyMarkerLegacyNV.html)"]
	#[inline]
	pub unsafe fn set_latency_marker_legacy_nv(
		&self,
		frame_id: u64,
		marker: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { set_latency_marker_legacy_nv(self, frame_id, marker) }
	}
}

/// Call `vkGetLatencyTimingsLegacyNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetLatencyTimingsLegacyNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetLatencyTimingsLegacyNV")]
#[doc = "\n\n[Khronos reference: `vkGetLatencyTimingsLegacyNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetLatencyTimingsLegacyNV.html)"]
pub unsafe fn get_latency_timings_legacy_nv(
	device: &Device,
	p_timings: *mut std::ffi::c_void,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_latency_timings_legacy_nv
		.ok_or(CallError::MissingCommand("vkGetLatencyTimingsLegacyNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_timings) };
	Ok(())
}

impl Device {
	/// Call `vkGetLatencyTimingsLegacyNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetLatencyTimingsLegacyNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetLatencyTimingsLegacyNV")]
	#[doc = "\n\n[Khronos reference: `vkGetLatencyTimingsLegacyNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetLatencyTimingsLegacyNV.html)"]
	#[inline]
	pub unsafe fn get_latency_timings_legacy_nv(
		&self,
		p_timings: *mut std::ffi::c_void,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_latency_timings_legacy_nv(self, p_timings) }
	}
}

/// Call `vkQueueNotifyOutOfBandLegacyNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkQueueNotifyOutOfBandLegacyNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkQueueNotifyOutOfBandLegacyNV")]
#[doc = "\n\n[Khronos reference: `vkQueueNotifyOutOfBandLegacyNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueueNotifyOutOfBandLegacyNV.html)"]
pub unsafe fn queue_notify_out_of_band_legacy_nv(
	device: &Device,
	queue: vk::Queue,
	queue_type: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.queue_notify_out_of_band_legacy_nv
		.ok_or(CallError::MissingCommand("vkQueueNotifyOutOfBandLegacyNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(queue, queue_type) };
	Ok(())
}

impl Device {
	/// Call `vkQueueNotifyOutOfBandLegacyNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkQueueNotifyOutOfBandLegacyNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkQueueNotifyOutOfBandLegacyNV")]
	#[doc = "\n\n[Khronos reference: `vkQueueNotifyOutOfBandLegacyNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueueNotifyOutOfBandLegacyNV.html)"]
	#[inline]
	pub unsafe fn queue_notify_out_of_band_legacy_nv(
		&self,
		queue: vk::Queue,
		queue_type: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { queue_notify_out_of_band_legacy_nv(self, queue, queue_type) }
	}
}

/// Call `vkGetSleepStatusLegacyNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetSleepStatusLegacyNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetSleepStatusLegacyNV")]
#[doc = "\n\n[Khronos reference: `vkGetSleepStatusLegacyNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSleepStatusLegacyNV.html)"]
pub unsafe fn get_sleep_status_legacy_nv(
	device: &Device,
	p_low_latency_mode: *mut vk::Bool32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_sleep_status_legacy_nv
		.ok_or(CallError::MissingCommand("vkGetSleepStatusLegacyNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_low_latency_mode) };
	Ok(())
}

impl Device {
	/// Call `vkGetSleepStatusLegacyNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetSleepStatusLegacyNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetSleepStatusLegacyNV")]
	#[doc = "\n\n[Khronos reference: `vkGetSleepStatusLegacyNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetSleepStatusLegacyNV.html)"]
	#[inline]
	pub unsafe fn get_sleep_status_legacy_nv(
		&self,
		p_low_latency_mode: *mut vk::Bool32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_sleep_status_legacy_nv(self, p_low_latency_mode) }
	}
}

/// Call `vkShutdownLatencyDeviceLegacyNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkShutdownLatencyDeviceLegacyNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkShutdownLatencyDeviceLegacyNV")]
#[doc = "\n\n[Khronos reference: `vkShutdownLatencyDeviceLegacyNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkShutdownLatencyDeviceLegacyNV.html)"]
pub unsafe fn shutdown_latency_device_legacy_nv(device: &Device) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.shutdown_latency_device_legacy_nv
		.ok_or(CallError::MissingCommand("vkShutdownLatencyDeviceLegacyNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle()) };
	Ok(())
}

impl Device {
	/// Call `vkShutdownLatencyDeviceLegacyNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkShutdownLatencyDeviceLegacyNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkShutdownLatencyDeviceLegacyNV")]
	#[doc = "\n\n[Khronos reference: `vkShutdownLatencyDeviceLegacyNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkShutdownLatencyDeviceLegacyNV.html)"]
	#[inline]
	pub unsafe fn shutdown_latency_device_legacy_nv(&self) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { shutdown_latency_device_legacy_nv(self) }
	}
}

/// Call `vkCmdSetRenderingAttachmentLocations` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetRenderingAttachmentLocations` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetRenderingAttachmentLocations")]
#[doc = "\n\n[Khronos reference: `vkCmdSetRenderingAttachmentLocations`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetRenderingAttachmentLocations.html)"]
pub unsafe fn cmd_set_rendering_attachment_locations(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_location_info: *const vk::RenderingAttachmentLocationInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_rendering_attachment_locations
			.ok_or(CallError::MissingCommand(
				"vkCmdSetRenderingAttachmentLocations",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_location_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetRenderingAttachmentLocations` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetRenderingAttachmentLocations` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetRenderingAttachmentLocations")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetRenderingAttachmentLocations`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetRenderingAttachmentLocations.html)"]
	#[inline]
	pub unsafe fn cmd_set_rendering_attachment_locations(
		&self,
		command_buffer: vk::CommandBuffer,
		p_location_info: *const vk::RenderingAttachmentLocationInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_rendering_attachment_locations(self, command_buffer, p_location_info) }
	}
}

/// Call `vkCmdSetRenderingAttachmentLocationsKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetRenderingAttachmentLocationsKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetRenderingAttachmentLocationsKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdSetRenderingAttachmentLocationsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetRenderingAttachmentLocationsKHR.html)"]
pub unsafe fn cmd_set_rendering_attachment_locations_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_location_info: *const vk::RenderingAttachmentLocationInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_rendering_attachment_locations_khr
		.ok_or(CallError::MissingCommand(
			"vkCmdSetRenderingAttachmentLocationsKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_location_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetRenderingAttachmentLocationsKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetRenderingAttachmentLocationsKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetRenderingAttachmentLocationsKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetRenderingAttachmentLocationsKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetRenderingAttachmentLocationsKHR.html)"]
	#[inline]
	pub unsafe fn cmd_set_rendering_attachment_locations_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_location_info: *const vk::RenderingAttachmentLocationInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_rendering_attachment_locations_khr(self, command_buffer, p_location_info) }
	}
}

/// Call `vkCmdSetRenderingInputAttachmentIndices` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetRenderingInputAttachmentIndices` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetRenderingInputAttachmentIndices")]
#[doc = "\n\n[Khronos reference: `vkCmdSetRenderingInputAttachmentIndices`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetRenderingInputAttachmentIndices.html)"]
pub unsafe fn cmd_set_rendering_input_attachment_indices(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_input_attachment_index_info: *const vk::RenderingInputAttachmentIndexInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_rendering_input_attachment_indices
		.ok_or(CallError::MissingCommand(
			"vkCmdSetRenderingInputAttachmentIndices",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_input_attachment_index_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetRenderingInputAttachmentIndices` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetRenderingInputAttachmentIndices` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetRenderingInputAttachmentIndices")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetRenderingInputAttachmentIndices`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetRenderingInputAttachmentIndices.html)"]
	#[inline]
	pub unsafe fn cmd_set_rendering_input_attachment_indices(
		&self,
		command_buffer: vk::CommandBuffer,
		p_input_attachment_index_info: *const vk::RenderingInputAttachmentIndexInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_rendering_input_attachment_indices(
				self,
				command_buffer,
				p_input_attachment_index_info,
			)
		}
	}
}

/// Call `vkCmdSetRenderingInputAttachmentIndicesKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetRenderingInputAttachmentIndicesKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetRenderingInputAttachmentIndicesKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdSetRenderingInputAttachmentIndicesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetRenderingInputAttachmentIndicesKHR.html)"]
pub unsafe fn cmd_set_rendering_input_attachment_indices_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_input_attachment_index_info: *const vk::RenderingInputAttachmentIndexInfo<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_rendering_input_attachment_indices_khr
		.ok_or(CallError::MissingCommand(
			"vkCmdSetRenderingInputAttachmentIndicesKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_input_attachment_index_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetRenderingInputAttachmentIndicesKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetRenderingInputAttachmentIndicesKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetRenderingInputAttachmentIndicesKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetRenderingInputAttachmentIndicesKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetRenderingInputAttachmentIndicesKHR.html)"]
	#[inline]
	pub unsafe fn cmd_set_rendering_input_attachment_indices_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_input_attachment_index_info: *const vk::RenderingInputAttachmentIndexInfo<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_rendering_input_attachment_indices_khr(
				self,
				command_buffer,
				p_input_attachment_index_info,
			)
		}
	}
}

/// Call `vkCmdSetDepthClampRangeEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDepthClampRangeEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDepthClampRangeEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDepthClampRangeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthClampRangeEXT.html)"]
pub unsafe fn cmd_set_depth_clamp_range_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	depth_clamp_mode: vk::DepthClampModeEXT,
	p_depth_clamp_range: *const vk::DepthClampRangeEXT,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_depth_clamp_range_ext
		.ok_or(CallError::MissingCommand("vkCmdSetDepthClampRangeEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, depth_clamp_mode, p_depth_clamp_range) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDepthClampRangeEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDepthClampRangeEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDepthClampRangeEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDepthClampRangeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDepthClampRangeEXT.html)"]
	#[inline]
	pub unsafe fn cmd_set_depth_clamp_range_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		depth_clamp_mode: vk::DepthClampModeEXT,
		p_depth_clamp_range: *const vk::DepthClampRangeEXT,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_set_depth_clamp_range_ext(self, command_buffer, depth_clamp_mode, p_depth_clamp_range)
		}
	}
}

/// Call `vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html)"]
pub unsafe fn get_physical_device_cooperative_matrix_flexible_dimensions_properties_nv(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_property_count: *mut u32,
	p_properties: *mut vk::CooperativeMatrixFlexibleDimensionsPropertiesNV<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_cooperative_matrix_flexible_dimensions_properties_nv
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, p_property_count, p_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html)"]
	#[inline]
	pub unsafe fn get_physical_device_cooperative_matrix_flexible_dimensions_properties_nv(
		&self,
		physical_device: vk::PhysicalDevice,
		p_property_count: *mut u32,
		p_properties: *mut vk::CooperativeMatrixFlexibleDimensionsPropertiesNV<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_cooperative_matrix_flexible_dimensions_properties_nv(
				self,
				physical_device,
				p_property_count,
				p_properties,
			)
		}
	}
}

#[cfg(feature = "platform-metal")]
/// Call `vkGetMemoryMetalHandleEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetMemoryMetalHandleEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetMemoryMetalHandleEXT")]
#[doc = "\n\n[Khronos reference: `vkGetMemoryMetalHandleEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryMetalHandleEXT.html)"]
pub unsafe fn get_memory_metal_handle_ext(
	device: &Device,
	p_get_metal_handle_info: *const vk::MemoryGetMetalHandleInfoEXT<'_>,
	p_handle: *mut *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_memory_metal_handle_ext
		.ok_or(CallError::MissingCommand("vkGetMemoryMetalHandleEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_get_metal_handle_info, p_handle) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-metal")]
impl Device {
	/// Call `vkGetMemoryMetalHandleEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetMemoryMetalHandleEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetMemoryMetalHandleEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetMemoryMetalHandleEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryMetalHandleEXT.html)"]
	#[inline]
	pub unsafe fn get_memory_metal_handle_ext(
		&self,
		p_get_metal_handle_info: *const vk::MemoryGetMetalHandleInfoEXT<'_>,
		p_handle: *mut *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_memory_metal_handle_ext(self, p_get_metal_handle_info, p_handle) }
	}
}

#[cfg(feature = "platform-metal")]
/// Call `vkGetMemoryMetalHandlePropertiesEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetMemoryMetalHandlePropertiesEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetMemoryMetalHandlePropertiesEXT")]
#[doc = "\n\n[Khronos reference: `vkGetMemoryMetalHandlePropertiesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryMetalHandlePropertiesEXT.html)"]
pub unsafe fn get_memory_metal_handle_properties_ext(
	device: &Device,
	handle_type: vk::ExternalMemoryHandleTypeFlagBits,
	p_handle: *const std::ffi::c_void,
	p_memory_metal_handle_properties: *mut vk::MemoryMetalHandlePropertiesEXT<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.get_memory_metal_handle_properties_ext
			.ok_or(CallError::MissingCommand(
				"vkGetMemoryMetalHandlePropertiesEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			handle_type,
			p_handle,
			p_memory_metal_handle_properties,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-metal")]
impl Device {
	/// Call `vkGetMemoryMetalHandlePropertiesEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetMemoryMetalHandlePropertiesEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetMemoryMetalHandlePropertiesEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetMemoryMetalHandlePropertiesEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryMetalHandlePropertiesEXT.html)"]
	#[inline]
	pub unsafe fn get_memory_metal_handle_properties_ext(
		&self,
		handle_type: vk::ExternalMemoryHandleTypeFlagBits,
		p_handle: *const std::ffi::c_void,
		p_memory_metal_handle_properties: *mut vk::MemoryMetalHandlePropertiesEXT<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_memory_metal_handle_properties_ext(
				self,
				handle_type,
				p_handle,
				p_memory_metal_handle_properties,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceCooperativeVectorPropertiesNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceCooperativeVectorPropertiesNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceCooperativeVectorPropertiesNV")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceCooperativeVectorPropertiesNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html)"]
pub unsafe fn get_physical_device_cooperative_vector_properties_nv(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_property_count: *mut u32,
	p_properties: *mut vk::CooperativeVectorPropertiesNV<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_cooperative_vector_properties_nv
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceCooperativeVectorPropertiesNV",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, p_property_count, p_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceCooperativeVectorPropertiesNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceCooperativeVectorPropertiesNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceCooperativeVectorPropertiesNV")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceCooperativeVectorPropertiesNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html)"]
	#[inline]
	pub unsafe fn get_physical_device_cooperative_vector_properties_nv(
		&self,
		physical_device: vk::PhysicalDevice,
		p_property_count: *mut u32,
		p_properties: *mut vk::CooperativeVectorPropertiesNV<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_cooperative_vector_properties_nv(
				self,
				physical_device,
				p_property_count,
				p_properties,
			)
		}
	}
}

/// Call `vkConvertCooperativeVectorMatrixNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkConvertCooperativeVectorMatrixNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkConvertCooperativeVectorMatrixNV")]
#[doc = "\n\n[Khronos reference: `vkConvertCooperativeVectorMatrixNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkConvertCooperativeVectorMatrixNV.html)"]
pub unsafe fn convert_cooperative_vector_matrix_nv(
	device: &Device,
	p_info: *const vk::ConvertCooperativeVectorMatrixInfoNV<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.convert_cooperative_vector_matrix_nv
			.ok_or(CallError::MissingCommand(
				"vkConvertCooperativeVectorMatrixNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkConvertCooperativeVectorMatrixNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkConvertCooperativeVectorMatrixNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkConvertCooperativeVectorMatrixNV")]
	#[doc = "\n\n[Khronos reference: `vkConvertCooperativeVectorMatrixNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkConvertCooperativeVectorMatrixNV.html)"]
	#[inline]
	pub unsafe fn convert_cooperative_vector_matrix_nv(
		&self,
		p_info: *const vk::ConvertCooperativeVectorMatrixInfoNV<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { convert_cooperative_vector_matrix_nv(self, p_info) }
	}
}

/// Call `vkCmdConvertCooperativeVectorMatrixNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdConvertCooperativeVectorMatrixNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdConvertCooperativeVectorMatrixNV")]
#[doc = "\n\n[Khronos reference: `vkCmdConvertCooperativeVectorMatrixNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdConvertCooperativeVectorMatrixNV.html)"]
pub unsafe fn cmd_convert_cooperative_vector_matrix_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	info_count: u32,
	p_infos: *const vk::ConvertCooperativeVectorMatrixInfoNV<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_convert_cooperative_vector_matrix_nv
			.ok_or(CallError::MissingCommand(
				"vkCmdConvertCooperativeVectorMatrixNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, info_count, p_infos) };
	Ok(())
}

impl Device {
	/// Call `vkCmdConvertCooperativeVectorMatrixNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdConvertCooperativeVectorMatrixNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdConvertCooperativeVectorMatrixNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdConvertCooperativeVectorMatrixNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdConvertCooperativeVectorMatrixNV.html)"]
	#[inline]
	pub unsafe fn cmd_convert_cooperative_vector_matrix_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		info_count: u32,
		p_infos: *const vk::ConvertCooperativeVectorMatrixInfoNV<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_convert_cooperative_vector_matrix_nv(self, command_buffer, info_count, p_infos) }
	}
}

/// Call `vkCmdDispatchTileQCOM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDispatchTileQCOM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDispatchTileQCOM")]
#[doc = "\n\n[Khronos reference: `vkCmdDispatchTileQCOM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDispatchTileQCOM.html)"]
pub unsafe fn cmd_dispatch_tile_qcom(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_dispatch_tile_info: *const vk::DispatchTileInfoQCOM<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_dispatch_tile_qcom
		.ok_or(CallError::MissingCommand("vkCmdDispatchTileQCOM"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_dispatch_tile_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDispatchTileQCOM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDispatchTileQCOM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDispatchTileQCOM")]
	#[doc = "\n\n[Khronos reference: `vkCmdDispatchTileQCOM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDispatchTileQCOM.html)"]
	#[inline]
	pub unsafe fn cmd_dispatch_tile_qcom(
		&self,
		command_buffer: vk::CommandBuffer,
		p_dispatch_tile_info: *const vk::DispatchTileInfoQCOM<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_dispatch_tile_qcom(self, command_buffer, p_dispatch_tile_info) }
	}
}

/// Call `vkCmdBeginPerTileExecutionQCOM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBeginPerTileExecutionQCOM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBeginPerTileExecutionQCOM")]
#[doc = "\n\n[Khronos reference: `vkCmdBeginPerTileExecutionQCOM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginPerTileExecutionQCOM.html)"]
pub unsafe fn cmd_begin_per_tile_execution_qcom(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_per_tile_begin_info: *const vk::PerTileBeginInfoQCOM<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_begin_per_tile_execution_qcom
		.ok_or(CallError::MissingCommand("vkCmdBeginPerTileExecutionQCOM"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_per_tile_begin_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBeginPerTileExecutionQCOM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBeginPerTileExecutionQCOM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBeginPerTileExecutionQCOM")]
	#[doc = "\n\n[Khronos reference: `vkCmdBeginPerTileExecutionQCOM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginPerTileExecutionQCOM.html)"]
	#[inline]
	pub unsafe fn cmd_begin_per_tile_execution_qcom(
		&self,
		command_buffer: vk::CommandBuffer,
		p_per_tile_begin_info: *const vk::PerTileBeginInfoQCOM<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_begin_per_tile_execution_qcom(self, command_buffer, p_per_tile_begin_info) }
	}
}

/// Call `vkCmdEndPerTileExecutionQCOM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdEndPerTileExecutionQCOM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdEndPerTileExecutionQCOM")]
#[doc = "\n\n[Khronos reference: `vkCmdEndPerTileExecutionQCOM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndPerTileExecutionQCOM.html)"]
pub unsafe fn cmd_end_per_tile_execution_qcom(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_per_tile_end_info: *const vk::PerTileEndInfoQCOM<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_end_per_tile_execution_qcom
		.ok_or(CallError::MissingCommand("vkCmdEndPerTileExecutionQCOM"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_per_tile_end_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdEndPerTileExecutionQCOM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdEndPerTileExecutionQCOM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdEndPerTileExecutionQCOM")]
	#[doc = "\n\n[Khronos reference: `vkCmdEndPerTileExecutionQCOM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndPerTileExecutionQCOM.html)"]
	#[inline]
	pub unsafe fn cmd_end_per_tile_execution_qcom(
		&self,
		command_buffer: vk::CommandBuffer,
		p_per_tile_end_info: *const vk::PerTileEndInfoQCOM<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_end_per_tile_execution_qcom(self, command_buffer, p_per_tile_end_info) }
	}
}

/// Call `vkCreateExternalComputeQueueNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateExternalComputeQueueNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateExternalComputeQueueNV")]
#[doc = "\n\n[Khronos reference: `vkCreateExternalComputeQueueNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateExternalComputeQueueNV.html)"]
pub unsafe fn create_external_compute_queue_nv(
	device: &Device,
	p_create_info: *const vk::ExternalComputeQueueCreateInfoNV<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_external_queue: *mut vk::ExternalComputeQueueNV,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_external_compute_queue_nv
		.ok_or(CallError::MissingCommand("vkCreateExternalComputeQueueNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_create_info,
			p_allocator,
			p_external_queue,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateExternalComputeQueueNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateExternalComputeQueueNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateExternalComputeQueueNV")]
	#[doc = "\n\n[Khronos reference: `vkCreateExternalComputeQueueNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateExternalComputeQueueNV.html)"]
	#[inline]
	pub unsafe fn create_external_compute_queue_nv(
		&self,
		p_create_info: *const vk::ExternalComputeQueueCreateInfoNV<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_external_queue: *mut vk::ExternalComputeQueueNV,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_external_compute_queue_nv(self, p_create_info, p_allocator, p_external_queue) }
	}
}

/// Call `vkDestroyExternalComputeQueueNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyExternalComputeQueueNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyExternalComputeQueueNV")]
#[doc = "\n\n[Khronos reference: `vkDestroyExternalComputeQueueNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyExternalComputeQueueNV.html)"]
pub unsafe fn destroy_external_compute_queue_nv(
	device: &Device,
	external_queue: vk::ExternalComputeQueueNV,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_external_compute_queue_nv
		.ok_or(CallError::MissingCommand("vkDestroyExternalComputeQueueNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), external_queue, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyExternalComputeQueueNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyExternalComputeQueueNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyExternalComputeQueueNV")]
	#[doc = "\n\n[Khronos reference: `vkDestroyExternalComputeQueueNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyExternalComputeQueueNV.html)"]
	#[inline]
	pub unsafe fn destroy_external_compute_queue_nv(
		&self,
		external_queue: vk::ExternalComputeQueueNV,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_external_compute_queue_nv(self, external_queue, p_allocator) }
	}
}

/// Call `vkGetExternalComputeQueueDataNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetExternalComputeQueueDataNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetExternalComputeQueueDataNV")]
#[doc = "\n\n[Khronos reference: `vkGetExternalComputeQueueDataNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetExternalComputeQueueDataNV.html)"]
pub unsafe fn get_external_compute_queue_data_nv(
	device: &Device,
	external_queue: vk::ExternalComputeQueueNV,
	params: *mut vk::ExternalComputeQueueDataParamsNV<'_>,
	p_data: *mut std::ffi::c_void,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_external_compute_queue_data_nv
		.ok_or(CallError::MissingCommand("vkGetExternalComputeQueueDataNV"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(external_queue, params, p_data) };
	Ok(())
}

impl Device {
	/// Call `vkGetExternalComputeQueueDataNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetExternalComputeQueueDataNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetExternalComputeQueueDataNV")]
	#[doc = "\n\n[Khronos reference: `vkGetExternalComputeQueueDataNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetExternalComputeQueueDataNV.html)"]
	#[inline]
	pub unsafe fn get_external_compute_queue_data_nv(
		&self,
		external_queue: vk::ExternalComputeQueueNV,
		params: *mut vk::ExternalComputeQueueDataParamsNV<'_>,
		p_data: *mut std::ffi::c_void,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_external_compute_queue_data_nv(self, external_queue, params, p_data) }
	}
}

/// Call `vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM")]
#[doc = "\n\n[Khronos reference: `vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM.html)"]
pub unsafe fn enumerate_physical_device_shader_instrumentation_metrics_arm(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_description_count: *mut u32,
	p_descriptions: *mut vk::ShaderInstrumentationMetricDescriptionARM<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.enumerate_physical_device_shader_instrumentation_metrics_arm
		.ok_or(CallError::MissingCommand(
			"vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, p_description_count, p_descriptions) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM")]
	#[doc = "\n\n[Khronos reference: `vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM.html)"]
	#[inline]
	pub unsafe fn enumerate_physical_device_shader_instrumentation_metrics_arm(
		&self,
		physical_device: vk::PhysicalDevice,
		p_description_count: *mut u32,
		p_descriptions: *mut vk::ShaderInstrumentationMetricDescriptionARM<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			enumerate_physical_device_shader_instrumentation_metrics_arm(
				self,
				physical_device,
				p_description_count,
				p_descriptions,
			)
		}
	}
}

/// Call `vkCreateShaderInstrumentationARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateShaderInstrumentationARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateShaderInstrumentationARM")]
#[doc = "\n\n[Khronos reference: `vkCreateShaderInstrumentationARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateShaderInstrumentationARM.html)"]
pub unsafe fn create_shader_instrumentation_arm(
	device: &Device,
	p_create_info: *const vk::ShaderInstrumentationCreateInfoARM<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_instrumentation: *mut vk::ShaderInstrumentationARM,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.create_shader_instrumentation_arm
			.ok_or(CallError::MissingCommand(
				"vkCreateShaderInstrumentationARM",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_create_info,
			p_allocator,
			p_instrumentation,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateShaderInstrumentationARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateShaderInstrumentationARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateShaderInstrumentationARM")]
	#[doc = "\n\n[Khronos reference: `vkCreateShaderInstrumentationARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateShaderInstrumentationARM.html)"]
	#[inline]
	pub unsafe fn create_shader_instrumentation_arm(
		&self,
		p_create_info: *const vk::ShaderInstrumentationCreateInfoARM<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_instrumentation: *mut vk::ShaderInstrumentationARM,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			create_shader_instrumentation_arm(self, p_create_info, p_allocator, p_instrumentation)
		}
	}
}

/// Call `vkDestroyShaderInstrumentationARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyShaderInstrumentationARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyShaderInstrumentationARM")]
#[doc = "\n\n[Khronos reference: `vkDestroyShaderInstrumentationARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyShaderInstrumentationARM.html)"]
pub unsafe fn destroy_shader_instrumentation_arm(
	device: &Device,
	instrumentation: vk::ShaderInstrumentationARM,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.destroy_shader_instrumentation_arm
			.ok_or(CallError::MissingCommand(
				"vkDestroyShaderInstrumentationARM",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), instrumentation, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyShaderInstrumentationARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyShaderInstrumentationARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyShaderInstrumentationARM")]
	#[doc = "\n\n[Khronos reference: `vkDestroyShaderInstrumentationARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyShaderInstrumentationARM.html)"]
	#[inline]
	pub unsafe fn destroy_shader_instrumentation_arm(
		&self,
		instrumentation: vk::ShaderInstrumentationARM,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_shader_instrumentation_arm(self, instrumentation, p_allocator) }
	}
}

/// Call `vkCmdBeginShaderInstrumentationARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBeginShaderInstrumentationARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBeginShaderInstrumentationARM")]
#[doc = "\n\n[Khronos reference: `vkCmdBeginShaderInstrumentationARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginShaderInstrumentationARM.html)"]
pub unsafe fn cmd_begin_shader_instrumentation_arm(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	instrumentation: vk::ShaderInstrumentationARM,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_begin_shader_instrumentation_arm
			.ok_or(CallError::MissingCommand(
				"vkCmdBeginShaderInstrumentationARM",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, instrumentation) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBeginShaderInstrumentationARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBeginShaderInstrumentationARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBeginShaderInstrumentationARM")]
	#[doc = "\n\n[Khronos reference: `vkCmdBeginShaderInstrumentationARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginShaderInstrumentationARM.html)"]
	#[inline]
	pub unsafe fn cmd_begin_shader_instrumentation_arm(
		&self,
		command_buffer: vk::CommandBuffer,
		instrumentation: vk::ShaderInstrumentationARM,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_begin_shader_instrumentation_arm(self, command_buffer, instrumentation) }
	}
}

/// Call `vkCmdEndShaderInstrumentationARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdEndShaderInstrumentationARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdEndShaderInstrumentationARM")]
#[doc = "\n\n[Khronos reference: `vkCmdEndShaderInstrumentationARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndShaderInstrumentationARM.html)"]
pub unsafe fn cmd_end_shader_instrumentation_arm(
	device: &Device,
	command_buffer: vk::CommandBuffer,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_end_shader_instrumentation_arm
			.ok_or(CallError::MissingCommand(
				"vkCmdEndShaderInstrumentationARM",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer) };
	Ok(())
}

impl Device {
	/// Call `vkCmdEndShaderInstrumentationARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdEndShaderInstrumentationARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdEndShaderInstrumentationARM")]
	#[doc = "\n\n[Khronos reference: `vkCmdEndShaderInstrumentationARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndShaderInstrumentationARM.html)"]
	#[inline]
	pub unsafe fn cmd_end_shader_instrumentation_arm(
		&self,
		command_buffer: vk::CommandBuffer,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_end_shader_instrumentation_arm(self, command_buffer) }
	}
}

/// Call `vkGetShaderInstrumentationValuesARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetShaderInstrumentationValuesARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetShaderInstrumentationValuesARM")]
#[doc = "\n\n[Khronos reference: `vkGetShaderInstrumentationValuesARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetShaderInstrumentationValuesARM.html)"]
pub unsafe fn get_shader_instrumentation_values_arm(
	device: &Device,
	instrumentation: vk::ShaderInstrumentationARM,
	p_metric_block_count: *mut u32,
	p_metric_values: *mut std::ffi::c_void,
	flags: vk::ShaderInstrumentationValuesFlagsARM,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.get_shader_instrumentation_values_arm
			.ok_or(CallError::MissingCommand(
				"vkGetShaderInstrumentationValuesARM",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			instrumentation,
			p_metric_block_count,
			p_metric_values,
			flags,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetShaderInstrumentationValuesARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetShaderInstrumentationValuesARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetShaderInstrumentationValuesARM")]
	#[doc = "\n\n[Khronos reference: `vkGetShaderInstrumentationValuesARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetShaderInstrumentationValuesARM.html)"]
	#[inline]
	pub unsafe fn get_shader_instrumentation_values_arm(
		&self,
		instrumentation: vk::ShaderInstrumentationARM,
		p_metric_block_count: *mut u32,
		p_metric_values: *mut std::ffi::c_void,
		flags: vk::ShaderInstrumentationValuesFlagsARM,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_shader_instrumentation_values_arm(
				self,
				instrumentation,
				p_metric_block_count,
				p_metric_values,
				flags,
			)
		}
	}
}

/// Call `vkClearShaderInstrumentationMetricsARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkClearShaderInstrumentationMetricsARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkClearShaderInstrumentationMetricsARM")]
#[doc = "\n\n[Khronos reference: `vkClearShaderInstrumentationMetricsARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkClearShaderInstrumentationMetricsARM.html)"]
pub unsafe fn clear_shader_instrumentation_metrics_arm(
	device: &Device,
	instrumentation: vk::ShaderInstrumentationARM,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.clear_shader_instrumentation_metrics_arm
			.ok_or(CallError::MissingCommand(
				"vkClearShaderInstrumentationMetricsARM",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), instrumentation) };
	Ok(())
}

impl Device {
	/// Call `vkClearShaderInstrumentationMetricsARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkClearShaderInstrumentationMetricsARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkClearShaderInstrumentationMetricsARM")]
	#[doc = "\n\n[Khronos reference: `vkClearShaderInstrumentationMetricsARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkClearShaderInstrumentationMetricsARM.html)"]
	#[inline]
	pub unsafe fn clear_shader_instrumentation_metrics_arm(
		&self,
		instrumentation: vk::ShaderInstrumentationARM,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { clear_shader_instrumentation_metrics_arm(self, instrumentation) }
	}
}

/// Call `vkCreateTensorARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateTensorARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateTensorARM")]
#[doc = "\n\n[Khronos reference: `vkCreateTensorARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateTensorARM.html)"]
pub unsafe fn create_tensor_arm(
	device: &Device,
	p_create_info: *const vk::TensorCreateInfoARM<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_tensor: *mut vk::TensorARM,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_tensor_arm
		.ok_or(CallError::MissingCommand("vkCreateTensorARM"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_create_info, p_allocator, p_tensor) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateTensorARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateTensorARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateTensorARM")]
	#[doc = "\n\n[Khronos reference: `vkCreateTensorARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateTensorARM.html)"]
	#[inline]
	pub unsafe fn create_tensor_arm(
		&self,
		p_create_info: *const vk::TensorCreateInfoARM<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_tensor: *mut vk::TensorARM,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_tensor_arm(self, p_create_info, p_allocator, p_tensor) }
	}
}

/// Call `vkDestroyTensorARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyTensorARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyTensorARM")]
#[doc = "\n\n[Khronos reference: `vkDestroyTensorARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyTensorARM.html)"]
pub unsafe fn destroy_tensor_arm(
	device: &Device,
	tensor: vk::TensorARM,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_tensor_arm
		.ok_or(CallError::MissingCommand("vkDestroyTensorARM"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), tensor, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyTensorARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyTensorARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyTensorARM")]
	#[doc = "\n\n[Khronos reference: `vkDestroyTensorARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyTensorARM.html)"]
	#[inline]
	pub unsafe fn destroy_tensor_arm(
		&self,
		tensor: vk::TensorARM,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_tensor_arm(self, tensor, p_allocator) }
	}
}

/// Call `vkCreateTensorViewARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateTensorViewARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateTensorViewARM")]
#[doc = "\n\n[Khronos reference: `vkCreateTensorViewARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateTensorViewARM.html)"]
pub unsafe fn create_tensor_view_arm(
	device: &Device,
	p_create_info: *const vk::TensorViewCreateInfoARM<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_view: *mut vk::TensorViewARM,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_tensor_view_arm
		.ok_or(CallError::MissingCommand("vkCreateTensorViewARM"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_create_info, p_allocator, p_view) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateTensorViewARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateTensorViewARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateTensorViewARM")]
	#[doc = "\n\n[Khronos reference: `vkCreateTensorViewARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateTensorViewARM.html)"]
	#[inline]
	pub unsafe fn create_tensor_view_arm(
		&self,
		p_create_info: *const vk::TensorViewCreateInfoARM<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_view: *mut vk::TensorViewARM,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_tensor_view_arm(self, p_create_info, p_allocator, p_view) }
	}
}

/// Call `vkDestroyTensorViewARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyTensorViewARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyTensorViewARM")]
#[doc = "\n\n[Khronos reference: `vkDestroyTensorViewARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyTensorViewARM.html)"]
pub unsafe fn destroy_tensor_view_arm(
	device: &Device,
	tensor_view: vk::TensorViewARM,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.destroy_tensor_view_arm
		.ok_or(CallError::MissingCommand("vkDestroyTensorViewARM"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), tensor_view, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyTensorViewARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyTensorViewARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyTensorViewARM")]
	#[doc = "\n\n[Khronos reference: `vkDestroyTensorViewARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyTensorViewARM.html)"]
	#[inline]
	pub unsafe fn destroy_tensor_view_arm(
		&self,
		tensor_view: vk::TensorViewARM,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_tensor_view_arm(self, tensor_view, p_allocator) }
	}
}

/// Call `vkGetTensorMemoryRequirementsARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetTensorMemoryRequirementsARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetTensorMemoryRequirementsARM")]
#[doc = "\n\n[Khronos reference: `vkGetTensorMemoryRequirementsARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetTensorMemoryRequirementsARM.html)"]
pub unsafe fn get_tensor_memory_requirements_arm(
	device: &Device,
	p_info: *const vk::TensorMemoryRequirementsInfoARM<'_>,
	p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.get_tensor_memory_requirements_arm
			.ok_or(CallError::MissingCommand(
				"vkGetTensorMemoryRequirementsARM",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_info, p_memory_requirements) };
	Ok(())
}

impl Device {
	/// Call `vkGetTensorMemoryRequirementsARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetTensorMemoryRequirementsARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetTensorMemoryRequirementsARM")]
	#[doc = "\n\n[Khronos reference: `vkGetTensorMemoryRequirementsARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetTensorMemoryRequirementsARM.html)"]
	#[inline]
	pub unsafe fn get_tensor_memory_requirements_arm(
		&self,
		p_info: *const vk::TensorMemoryRequirementsInfoARM<'_>,
		p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_tensor_memory_requirements_arm(self, p_info, p_memory_requirements) }
	}
}

/// Call `vkBindTensorMemoryARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkBindTensorMemoryARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkBindTensorMemoryARM")]
#[doc = "\n\n[Khronos reference: `vkBindTensorMemoryARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBindTensorMemoryARM.html)"]
pub unsafe fn bind_tensor_memory_arm(
	device: &Device,
	bind_info_count: u32,
	p_bind_infos: *const vk::BindTensorMemoryInfoARM<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.bind_tensor_memory_arm
		.ok_or(CallError::MissingCommand("vkBindTensorMemoryARM"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), bind_info_count, p_bind_infos) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkBindTensorMemoryARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkBindTensorMemoryARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkBindTensorMemoryARM")]
	#[doc = "\n\n[Khronos reference: `vkBindTensorMemoryARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBindTensorMemoryARM.html)"]
	#[inline]
	pub unsafe fn bind_tensor_memory_arm(
		&self,
		bind_info_count: u32,
		p_bind_infos: *const vk::BindTensorMemoryInfoARM<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { bind_tensor_memory_arm(self, bind_info_count, p_bind_infos) }
	}
}

/// Call `vkGetDeviceTensorMemoryRequirementsARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDeviceTensorMemoryRequirementsARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDeviceTensorMemoryRequirementsARM")]
#[doc = "\n\n[Khronos reference: `vkGetDeviceTensorMemoryRequirementsARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceTensorMemoryRequirementsARM.html)"]
pub unsafe fn get_device_tensor_memory_requirements_arm(
	device: &Device,
	p_info: *const vk::DeviceTensorMemoryRequirementsARM<'_>,
	p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_device_tensor_memory_requirements_arm
		.ok_or(CallError::MissingCommand(
			"vkGetDeviceTensorMemoryRequirementsARM",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_info, p_memory_requirements) };
	Ok(())
}

impl Device {
	/// Call `vkGetDeviceTensorMemoryRequirementsARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDeviceTensorMemoryRequirementsARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDeviceTensorMemoryRequirementsARM")]
	#[doc = "\n\n[Khronos reference: `vkGetDeviceTensorMemoryRequirementsARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDeviceTensorMemoryRequirementsARM.html)"]
	#[inline]
	pub unsafe fn get_device_tensor_memory_requirements_arm(
		&self,
		p_info: *const vk::DeviceTensorMemoryRequirementsARM<'_>,
		p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_device_tensor_memory_requirements_arm(self, p_info, p_memory_requirements) }
	}
}

/// Call `vkCmdCopyTensorARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyTensorARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdCopyTensorARM")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyTensorARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyTensorARM.html)"]
pub unsafe fn cmd_copy_tensor_arm(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_copy_tensor_info: *const vk::CopyTensorInfoARM<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_tensor_arm
		.ok_or(CallError::MissingCommand("vkCmdCopyTensorARM"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_copy_tensor_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyTensorARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyTensorARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdCopyTensorARM")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyTensorARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyTensorARM.html)"]
	#[inline]
	pub unsafe fn cmd_copy_tensor_arm(
		&self,
		command_buffer: vk::CommandBuffer,
		p_copy_tensor_info: *const vk::CopyTensorInfoARM<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_tensor_arm(self, command_buffer, p_copy_tensor_info) }
	}
}

/// Call `vkGetTensorOpaqueCaptureDescriptorDataARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetTensorOpaqueCaptureDescriptorDataARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetTensorOpaqueCaptureDescriptorDataARM")]
#[doc = "\n\n[Khronos reference: `vkGetTensorOpaqueCaptureDescriptorDataARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetTensorOpaqueCaptureDescriptorDataARM.html)"]
pub unsafe fn get_tensor_opaque_capture_descriptor_data_arm(
	device: &Device,
	p_info: *const vk::TensorCaptureDescriptorDataInfoARM<'_>,
	p_data: *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_tensor_opaque_capture_descriptor_data_arm
		.ok_or(CallError::MissingCommand(
			"vkGetTensorOpaqueCaptureDescriptorDataARM",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_info, p_data) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetTensorOpaqueCaptureDescriptorDataARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetTensorOpaqueCaptureDescriptorDataARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetTensorOpaqueCaptureDescriptorDataARM")]
	#[doc = "\n\n[Khronos reference: `vkGetTensorOpaqueCaptureDescriptorDataARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetTensorOpaqueCaptureDescriptorDataARM.html)"]
	#[inline]
	pub unsafe fn get_tensor_opaque_capture_descriptor_data_arm(
		&self,
		p_info: *const vk::TensorCaptureDescriptorDataInfoARM<'_>,
		p_data: *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_tensor_opaque_capture_descriptor_data_arm(self, p_info, p_data) }
	}
}

/// Call `vkGetTensorViewOpaqueCaptureDescriptorDataARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetTensorViewOpaqueCaptureDescriptorDataARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetTensorViewOpaqueCaptureDescriptorDataARM")]
#[doc = "\n\n[Khronos reference: `vkGetTensorViewOpaqueCaptureDescriptorDataARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html)"]
pub unsafe fn get_tensor_view_opaque_capture_descriptor_data_arm(
	device: &Device,
	p_info: *const vk::TensorViewCaptureDescriptorDataInfoARM<'_>,
	p_data: *mut std::ffi::c_void,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_tensor_view_opaque_capture_descriptor_data_arm
		.ok_or(CallError::MissingCommand(
			"vkGetTensorViewOpaqueCaptureDescriptorDataARM",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_info, p_data) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetTensorViewOpaqueCaptureDescriptorDataARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetTensorViewOpaqueCaptureDescriptorDataARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetTensorViewOpaqueCaptureDescriptorDataARM")]
	#[doc = "\n\n[Khronos reference: `vkGetTensorViewOpaqueCaptureDescriptorDataARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html)"]
	#[inline]
	pub unsafe fn get_tensor_view_opaque_capture_descriptor_data_arm(
		&self,
		p_info: *const vk::TensorViewCaptureDescriptorDataInfoARM<'_>,
		p_data: *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_tensor_view_opaque_capture_descriptor_data_arm(self, p_info, p_data) }
	}
}

/// Call `vkGetPhysicalDeviceExternalTensorPropertiesARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceExternalTensorPropertiesARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceExternalTensorPropertiesARM")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceExternalTensorPropertiesARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceExternalTensorPropertiesARM.html)"]
pub unsafe fn get_physical_device_external_tensor_properties_arm(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_external_tensor_info: *const vk::PhysicalDeviceExternalTensorInfoARM<'_>,
	p_external_tensor_properties: *mut vk::ExternalTensorPropertiesARM<'_>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_external_tensor_properties_arm
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceExternalTensorPropertiesARM",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			physical_device,
			p_external_tensor_info,
			p_external_tensor_properties,
		)
	};
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceExternalTensorPropertiesARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceExternalTensorPropertiesARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceExternalTensorPropertiesARM")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceExternalTensorPropertiesARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceExternalTensorPropertiesARM.html)"]
	#[inline]
	pub unsafe fn get_physical_device_external_tensor_properties_arm(
		&self,
		physical_device: vk::PhysicalDevice,
		p_external_tensor_info: *const vk::PhysicalDeviceExternalTensorInfoARM<'_>,
		p_external_tensor_properties: *mut vk::ExternalTensorPropertiesARM<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_external_tensor_properties_arm(
				self,
				physical_device,
				p_external_tensor_info,
				p_external_tensor_properties,
			)
		}
	}
}

/// Call `vkCreateDataGraphPipelinesARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateDataGraphPipelinesARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateDataGraphPipelinesARM")]
#[doc = "\n\n[Khronos reference: `vkCreateDataGraphPipelinesARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDataGraphPipelinesARM.html)"]
pub unsafe fn create_data_graph_pipelines_arm(
	device: &Device,
	deferred_operation: vk::DeferredOperationKHR,
	pipeline_cache: vk::PipelineCache,
	create_info_count: u32,
	p_create_infos: *const vk::DataGraphPipelineCreateInfoARM<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_pipelines: *mut vk::Pipeline,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.create_data_graph_pipelines_arm
		.ok_or(CallError::MissingCommand("vkCreateDataGraphPipelinesARM"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			deferred_operation,
			pipeline_cache,
			create_info_count,
			p_create_infos,
			p_allocator,
			p_pipelines,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateDataGraphPipelinesARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateDataGraphPipelinesARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateDataGraphPipelinesARM")]
	#[doc = "\n\n[Khronos reference: `vkCreateDataGraphPipelinesARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDataGraphPipelinesARM.html)"]
	#[inline]
	pub unsafe fn create_data_graph_pipelines_arm(
		&self,
		deferred_operation: vk::DeferredOperationKHR,
		pipeline_cache: vk::PipelineCache,
		create_info_count: u32,
		p_create_infos: *const vk::DataGraphPipelineCreateInfoARM<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_pipelines: *mut vk::Pipeline,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			create_data_graph_pipelines_arm(
				self,
				deferred_operation,
				pipeline_cache,
				create_info_count,
				p_create_infos,
				p_allocator,
				p_pipelines,
			)
		}
	}
}

/// Call `vkCreateDataGraphPipelineSessionARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateDataGraphPipelineSessionARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateDataGraphPipelineSessionARM")]
#[doc = "\n\n[Khronos reference: `vkCreateDataGraphPipelineSessionARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDataGraphPipelineSessionARM.html)"]
pub unsafe fn create_data_graph_pipeline_session_arm(
	device: &Device,
	p_create_info: *const vk::DataGraphPipelineSessionCreateInfoARM<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_session: *mut vk::DataGraphPipelineSessionARM,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.create_data_graph_pipeline_session_arm
			.ok_or(CallError::MissingCommand(
				"vkCreateDataGraphPipelineSessionARM",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_create_info, p_allocator, p_session) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateDataGraphPipelineSessionARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateDataGraphPipelineSessionARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateDataGraphPipelineSessionARM")]
	#[doc = "\n\n[Khronos reference: `vkCreateDataGraphPipelineSessionARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateDataGraphPipelineSessionARM.html)"]
	#[inline]
	pub unsafe fn create_data_graph_pipeline_session_arm(
		&self,
		p_create_info: *const vk::DataGraphPipelineSessionCreateInfoARM<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_session: *mut vk::DataGraphPipelineSessionARM,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { create_data_graph_pipeline_session_arm(self, p_create_info, p_allocator, p_session) }
	}
}

/// Call `vkGetDataGraphPipelineSessionBindPointRequirementsARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDataGraphPipelineSessionBindPointRequirementsARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDataGraphPipelineSessionBindPointRequirementsARM")]
#[doc = "\n\n[Khronos reference: `vkGetDataGraphPipelineSessionBindPointRequirementsARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html)"]
pub unsafe fn get_data_graph_pipeline_session_bind_point_requirements_arm(
	device: &Device,
	p_info: *const vk::DataGraphPipelineSessionBindPointRequirementsInfoARM<'_>,
	p_bind_point_requirement_count: *mut u32,
	p_bind_point_requirements: *mut vk::DataGraphPipelineSessionBindPointRequirementARM<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_data_graph_pipeline_session_bind_point_requirements_arm
		.ok_or(CallError::MissingCommand(
			"vkGetDataGraphPipelineSessionBindPointRequirementsARM",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_info,
			p_bind_point_requirement_count,
			p_bind_point_requirements,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetDataGraphPipelineSessionBindPointRequirementsARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDataGraphPipelineSessionBindPointRequirementsARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDataGraphPipelineSessionBindPointRequirementsARM")]
	#[doc = "\n\n[Khronos reference: `vkGetDataGraphPipelineSessionBindPointRequirementsARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html)"]
	#[inline]
	pub unsafe fn get_data_graph_pipeline_session_bind_point_requirements_arm(
		&self,
		p_info: *const vk::DataGraphPipelineSessionBindPointRequirementsInfoARM<'_>,
		p_bind_point_requirement_count: *mut u32,
		p_bind_point_requirements: *mut vk::DataGraphPipelineSessionBindPointRequirementARM<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_data_graph_pipeline_session_bind_point_requirements_arm(
				self,
				p_info,
				p_bind_point_requirement_count,
				p_bind_point_requirements,
			)
		}
	}
}

/// Call `vkGetDataGraphPipelineSessionMemoryRequirementsARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDataGraphPipelineSessionMemoryRequirementsARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDataGraphPipelineSessionMemoryRequirementsARM")]
#[doc = "\n\n[Khronos reference: `vkGetDataGraphPipelineSessionMemoryRequirementsARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html)"]
pub unsafe fn get_data_graph_pipeline_session_memory_requirements_arm(
	device: &Device,
	p_info: *const vk::DataGraphPipelineSessionMemoryRequirementsInfoARM<'_>,
	p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.get_data_graph_pipeline_session_memory_requirements_arm
		.ok_or(CallError::MissingCommand(
			"vkGetDataGraphPipelineSessionMemoryRequirementsARM",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), p_info, p_memory_requirements) };
	Ok(())
}

impl Device {
	/// Call `vkGetDataGraphPipelineSessionMemoryRequirementsARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDataGraphPipelineSessionMemoryRequirementsARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDataGraphPipelineSessionMemoryRequirementsARM")]
	#[doc = "\n\n[Khronos reference: `vkGetDataGraphPipelineSessionMemoryRequirementsARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html)"]
	#[inline]
	pub unsafe fn get_data_graph_pipeline_session_memory_requirements_arm(
		&self,
		p_info: *const vk::DataGraphPipelineSessionMemoryRequirementsInfoARM<'_>,
		p_memory_requirements: *mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_data_graph_pipeline_session_memory_requirements_arm(self, p_info, p_memory_requirements)
		}
	}
}

/// Call `vkBindDataGraphPipelineSessionMemoryARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkBindDataGraphPipelineSessionMemoryARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkBindDataGraphPipelineSessionMemoryARM")]
#[doc = "\n\n[Khronos reference: `vkBindDataGraphPipelineSessionMemoryARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBindDataGraphPipelineSessionMemoryARM.html)"]
pub unsafe fn bind_data_graph_pipeline_session_memory_arm(
	device: &Device,
	bind_info_count: u32,
	p_bind_infos: *const vk::BindDataGraphPipelineSessionMemoryInfoARM<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.bind_data_graph_pipeline_session_memory_arm
		.ok_or(CallError::MissingCommand(
			"vkBindDataGraphPipelineSessionMemoryARM",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), bind_info_count, p_bind_infos) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkBindDataGraphPipelineSessionMemoryARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkBindDataGraphPipelineSessionMemoryARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkBindDataGraphPipelineSessionMemoryARM")]
	#[doc = "\n\n[Khronos reference: `vkBindDataGraphPipelineSessionMemoryARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkBindDataGraphPipelineSessionMemoryARM.html)"]
	#[inline]
	pub unsafe fn bind_data_graph_pipeline_session_memory_arm(
		&self,
		bind_info_count: u32,
		p_bind_infos: *const vk::BindDataGraphPipelineSessionMemoryInfoARM<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { bind_data_graph_pipeline_session_memory_arm(self, bind_info_count, p_bind_infos) }
	}
}

/// Call `vkDestroyDataGraphPipelineSessionARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkDestroyDataGraphPipelineSessionARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkDestroyDataGraphPipelineSessionARM")]
#[doc = "\n\n[Khronos reference: `vkDestroyDataGraphPipelineSessionARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyDataGraphPipelineSessionARM.html)"]
pub unsafe fn destroy_data_graph_pipeline_session_arm(
	device: &Device,
	session: vk::DataGraphPipelineSessionARM,
	p_allocator: *const vk::AllocationCallbacks,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.destroy_data_graph_pipeline_session_arm
			.ok_or(CallError::MissingCommand(
				"vkDestroyDataGraphPipelineSessionARM",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), session, p_allocator) };
	Ok(())
}

impl Device {
	/// Call `vkDestroyDataGraphPipelineSessionARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkDestroyDataGraphPipelineSessionARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkDestroyDataGraphPipelineSessionARM")]
	#[doc = "\n\n[Khronos reference: `vkDestroyDataGraphPipelineSessionARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkDestroyDataGraphPipelineSessionARM.html)"]
	#[inline]
	pub unsafe fn destroy_data_graph_pipeline_session_arm(
		&self,
		session: vk::DataGraphPipelineSessionARM,
		p_allocator: *const vk::AllocationCallbacks,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { destroy_data_graph_pipeline_session_arm(self, session, p_allocator) }
	}
}

/// Call `vkCmdDispatchDataGraphARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDispatchDataGraphARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDispatchDataGraphARM")]
#[doc = "\n\n[Khronos reference: `vkCmdDispatchDataGraphARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDispatchDataGraphARM.html)"]
pub unsafe fn cmd_dispatch_data_graph_arm(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	session: vk::DataGraphPipelineSessionARM,
	p_info: *const vk::DataGraphPipelineDispatchInfoARM<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_dispatch_data_graph_arm
		.ok_or(CallError::MissingCommand("vkCmdDispatchDataGraphARM"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, session, p_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDispatchDataGraphARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDispatchDataGraphARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDispatchDataGraphARM")]
	#[doc = "\n\n[Khronos reference: `vkCmdDispatchDataGraphARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDispatchDataGraphARM.html)"]
	#[inline]
	pub unsafe fn cmd_dispatch_data_graph_arm(
		&self,
		command_buffer: vk::CommandBuffer,
		session: vk::DataGraphPipelineSessionARM,
		p_info: *const vk::DataGraphPipelineDispatchInfoARM<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_dispatch_data_graph_arm(self, command_buffer, session, p_info) }
	}
}

/// Call `vkGetDataGraphPipelineAvailablePropertiesARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDataGraphPipelineAvailablePropertiesARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDataGraphPipelineAvailablePropertiesARM")]
#[doc = "\n\n[Khronos reference: `vkGetDataGraphPipelineAvailablePropertiesARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDataGraphPipelineAvailablePropertiesARM.html)"]
pub unsafe fn get_data_graph_pipeline_available_properties_arm(
	device: &Device,
	p_pipeline_info: *const vk::DataGraphPipelineInfoARM<'_>,
	p_properties_count: *mut u32,
	p_properties: *mut vk::DataGraphPipelinePropertyARM,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_data_graph_pipeline_available_properties_arm
		.ok_or(CallError::MissingCommand(
			"vkGetDataGraphPipelineAvailablePropertiesARM",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_pipeline_info,
			p_properties_count,
			p_properties,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetDataGraphPipelineAvailablePropertiesARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDataGraphPipelineAvailablePropertiesARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDataGraphPipelineAvailablePropertiesARM")]
	#[doc = "\n\n[Khronos reference: `vkGetDataGraphPipelineAvailablePropertiesARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDataGraphPipelineAvailablePropertiesARM.html)"]
	#[inline]
	pub unsafe fn get_data_graph_pipeline_available_properties_arm(
		&self,
		p_pipeline_info: *const vk::DataGraphPipelineInfoARM<'_>,
		p_properties_count: *mut u32,
		p_properties: *mut vk::DataGraphPipelinePropertyARM,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_data_graph_pipeline_available_properties_arm(
				self,
				p_pipeline_info,
				p_properties_count,
				p_properties,
			)
		}
	}
}

/// Call `vkGetDataGraphPipelinePropertiesARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetDataGraphPipelinePropertiesARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetDataGraphPipelinePropertiesARM")]
#[doc = "\n\n[Khronos reference: `vkGetDataGraphPipelinePropertiesARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDataGraphPipelinePropertiesARM.html)"]
pub unsafe fn get_data_graph_pipeline_properties_arm(
	device: &Device,
	p_pipeline_info: *const vk::DataGraphPipelineInfoARM<'_>,
	properties_count: u32,
	p_properties: *mut vk::DataGraphPipelinePropertyQueryResultARM<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.get_data_graph_pipeline_properties_arm
			.ok_or(CallError::MissingCommand(
				"vkGetDataGraphPipelinePropertiesARM",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_pipeline_info,
			properties_count,
			p_properties,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetDataGraphPipelinePropertiesARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetDataGraphPipelinePropertiesARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetDataGraphPipelinePropertiesARM")]
	#[doc = "\n\n[Khronos reference: `vkGetDataGraphPipelinePropertiesARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetDataGraphPipelinePropertiesARM.html)"]
	#[inline]
	pub unsafe fn get_data_graph_pipeline_properties_arm(
		&self,
		p_pipeline_info: *const vk::DataGraphPipelineInfoARM<'_>,
		properties_count: u32,
		p_properties: *mut vk::DataGraphPipelinePropertyQueryResultARM<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_data_graph_pipeline_properties_arm(self, p_pipeline_info, properties_count, p_properties)
		}
	}
}

/// Call `vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html)"]
pub unsafe fn get_physical_device_queue_family_data_graph_properties_arm(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	queue_family_index: u32,
	p_queue_family_data_graph_property_count: *mut u32,
	p_queue_family_data_graph_properties: *mut vk::QueueFamilyDataGraphPropertiesARM<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_queue_family_data_graph_properties_arm
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			physical_device,
			queue_family_index,
			p_queue_family_data_graph_property_count,
			p_queue_family_data_graph_properties,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html)"]
	#[inline]
	pub unsafe fn get_physical_device_queue_family_data_graph_properties_arm(
		&self,
		physical_device: vk::PhysicalDevice,
		queue_family_index: u32,
		p_queue_family_data_graph_property_count: *mut u32,
		p_queue_family_data_graph_properties: *mut vk::QueueFamilyDataGraphPropertiesARM<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_queue_family_data_graph_properties_arm(
				self,
				physical_device,
				queue_family_index,
				p_queue_family_data_graph_property_count,
				p_queue_family_data_graph_properties,
			)
		}
	}
}

/// Call `vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.html)"]
pub unsafe fn get_physical_device_queue_family_data_graph_processing_engine_properties_arm(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	p_queue_family_data_graph_processing_engine_info: *const vk::PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM<'_>,
	p_queue_family_data_graph_processing_engine_properties: *mut vk::QueueFamilyDataGraphProcessingEnginePropertiesARM<'_>,
) -> Result<(), CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_queue_family_data_graph_processing_engine_properties_arm
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			physical_device,
			p_queue_family_data_graph_processing_engine_info,
			p_queue_family_data_graph_processing_engine_properties,
		)
	};
	Ok(())
}

impl Instance {
	/// Call `vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.html)"]
	#[inline]
	pub unsafe fn get_physical_device_queue_family_data_graph_processing_engine_properties_arm(
		&self,
		physical_device: vk::PhysicalDevice,
		p_queue_family_data_graph_processing_engine_info: *const vk::PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM<'_>,
		p_queue_family_data_graph_processing_engine_properties: *mut vk::QueueFamilyDataGraphProcessingEnginePropertiesARM<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_queue_family_data_graph_processing_engine_properties_arm(
				self,
				physical_device,
				p_queue_family_data_graph_processing_engine_info,
				p_queue_family_data_graph_processing_engine_properties,
			)
		}
	}
}

#[cfg(feature = "platform-ohos")]
/// Call `vkGetNativeBufferPropertiesOHOS` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetNativeBufferPropertiesOHOS` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetNativeBufferPropertiesOHOS")]
#[doc = "\n\n[Khronos reference: `vkGetNativeBufferPropertiesOHOS`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetNativeBufferPropertiesOHOS.html)"]
pub unsafe fn get_native_buffer_properties_ohos(
	device: &Device,
	buffer: *const vk::OH_NativeBuffer,
	p_properties: *mut vk::NativeBufferPropertiesOHOS<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_native_buffer_properties_ohos
		.ok_or(CallError::MissingCommand("vkGetNativeBufferPropertiesOHOS"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), buffer, p_properties) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-ohos")]
impl Device {
	/// Call `vkGetNativeBufferPropertiesOHOS` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetNativeBufferPropertiesOHOS` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetNativeBufferPropertiesOHOS")]
	#[doc = "\n\n[Khronos reference: `vkGetNativeBufferPropertiesOHOS`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetNativeBufferPropertiesOHOS.html)"]
	#[inline]
	pub unsafe fn get_native_buffer_properties_ohos(
		&self,
		buffer: *const vk::OH_NativeBuffer,
		p_properties: *mut vk::NativeBufferPropertiesOHOS<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_native_buffer_properties_ohos(self, buffer, p_properties) }
	}
}

#[cfg(feature = "platform-ohos")]
/// Call `vkGetMemoryNativeBufferOHOS` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetMemoryNativeBufferOHOS` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetMemoryNativeBufferOHOS")]
#[doc = "\n\n[Khronos reference: `vkGetMemoryNativeBufferOHOS`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryNativeBufferOHOS.html)"]
pub unsafe fn get_memory_native_buffer_ohos(
	device: &Device,
	p_info: *const vk::MemoryGetNativeBufferInfoOHOS<'_>,
	p_buffer: *mut *mut vk::OH_NativeBuffer,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_memory_native_buffer_ohos
		.ok_or(CallError::MissingCommand("vkGetMemoryNativeBufferOHOS"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_info, p_buffer) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

#[cfg(feature = "platform-ohos")]
impl Device {
	/// Call `vkGetMemoryNativeBufferOHOS` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetMemoryNativeBufferOHOS` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetMemoryNativeBufferOHOS")]
	#[doc = "\n\n[Khronos reference: `vkGetMemoryNativeBufferOHOS`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetMemoryNativeBufferOHOS.html)"]
	#[inline]
	pub unsafe fn get_memory_native_buffer_ohos(
		&self,
		p_info: *const vk::MemoryGetNativeBufferInfoOHOS<'_>,
		p_buffer: *mut *mut vk::OH_NativeBuffer,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_memory_native_buffer_ohos(self, p_info, p_buffer) }
	}
}

/// Call `vkQueueSetPerfHintQCOM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkQueueSetPerfHintQCOM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkQueueSetPerfHintQCOM")]
#[doc = "\n\n[Khronos reference: `vkQueueSetPerfHintQCOM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueueSetPerfHintQCOM.html)"]
pub unsafe fn queue_set_perf_hint_qcom(
	device: &Device,
	queue: vk::Queue,
	p_perf_hint_info: *const vk::PerfHintInfoQCOM<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.queue_set_perf_hint_qcom
		.ok_or(CallError::MissingCommand("vkQueueSetPerfHintQCOM"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(queue, p_perf_hint_info) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkQueueSetPerfHintQCOM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkQueueSetPerfHintQCOM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkQueueSetPerfHintQCOM")]
	#[doc = "\n\n[Khronos reference: `vkQueueSetPerfHintQCOM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkQueueSetPerfHintQCOM.html)"]
	#[inline]
	pub unsafe fn queue_set_perf_hint_qcom(
		&self,
		queue: vk::Queue,
		p_perf_hint_info: *const vk::PerfHintInfoQCOM<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { queue_set_perf_hint_qcom(self, queue, p_perf_hint_info) }
	}
}

/// Call `vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM")]
#[doc = "\n\n[Khronos reference: `vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html)"]
pub unsafe fn enumerate_physical_device_queue_family_performance_counters_by_region_arm(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	queue_family_index: u32,
	p_counter_count: *mut u32,
	p_counters: *mut vk::PerformanceCounterARM<'_>,
	p_counter_descriptions: *mut vk::PerformanceCounterDescriptionARM<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.enumerate_physical_device_queue_family_performance_counters_by_region_arm
		.ok_or(CallError::MissingCommand(
			"vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			physical_device,
			queue_family_index,
			p_counter_count,
			p_counters,
			p_counter_descriptions,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM")]
	#[doc = "\n\n[Khronos reference: `vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html)"]
	#[inline]
	pub unsafe fn enumerate_physical_device_queue_family_performance_counters_by_region_arm(
		&self,
		physical_device: vk::PhysicalDevice,
		queue_family_index: u32,
		p_counter_count: *mut u32,
		p_counters: *mut vk::PerformanceCounterARM<'_>,
		p_counter_descriptions: *mut vk::PerformanceCounterDescriptionARM<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			enumerate_physical_device_queue_family_performance_counters_by_region_arm(
				self,
				physical_device,
				queue_family_index,
				p_counter_count,
				p_counters,
				p_counter_descriptions,
			)
		}
	}
}

/// Call `vkCmdSetComputeOccupancyPriorityNV` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetComputeOccupancyPriorityNV` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetComputeOccupancyPriorityNV")]
#[doc = "\n\n[Khronos reference: `vkCmdSetComputeOccupancyPriorityNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetComputeOccupancyPriorityNV.html)"]
pub unsafe fn cmd_set_compute_occupancy_priority_nv(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_parameters: *const vk::ComputeOccupancyPriorityParametersNV<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_set_compute_occupancy_priority_nv
			.ok_or(CallError::MissingCommand(
				"vkCmdSetComputeOccupancyPriorityNV",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_parameters) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetComputeOccupancyPriorityNV` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetComputeOccupancyPriorityNV` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetComputeOccupancyPriorityNV")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetComputeOccupancyPriorityNV`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetComputeOccupancyPriorityNV.html)"]
	#[inline]
	pub unsafe fn cmd_set_compute_occupancy_priority_nv(
		&self,
		command_buffer: vk::CommandBuffer,
		p_parameters: *const vk::ComputeOccupancyPriorityParametersNV<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_compute_occupancy_priority_nv(self, command_buffer, p_parameters) }
	}
}

/// Call `vkWriteSamplerDescriptorsEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkWriteSamplerDescriptorsEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkWriteSamplerDescriptorsEXT")]
#[doc = "\n\n[Khronos reference: `vkWriteSamplerDescriptorsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkWriteSamplerDescriptorsEXT.html)"]
pub unsafe fn write_sampler_descriptors_ext(
	device: &Device,
	sampler_count: u32,
	p_samplers: *const vk::SamplerCreateInfo<'_>,
	p_descriptors: *const vk::HostAddressRangeEXT<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.write_sampler_descriptors_ext
		.ok_or(CallError::MissingCommand("vkWriteSamplerDescriptorsEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), sampler_count, p_samplers, p_descriptors) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkWriteSamplerDescriptorsEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkWriteSamplerDescriptorsEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkWriteSamplerDescriptorsEXT")]
	#[doc = "\n\n[Khronos reference: `vkWriteSamplerDescriptorsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkWriteSamplerDescriptorsEXT.html)"]
	#[inline]
	pub unsafe fn write_sampler_descriptors_ext(
		&self,
		sampler_count: u32,
		p_samplers: *const vk::SamplerCreateInfo<'_>,
		p_descriptors: *const vk::HostAddressRangeEXT<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { write_sampler_descriptors_ext(self, sampler_count, p_samplers, p_descriptors) }
	}
}

/// Call `vkWriteResourceDescriptorsEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkWriteResourceDescriptorsEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkWriteResourceDescriptorsEXT")]
#[doc = "\n\n[Khronos reference: `vkWriteResourceDescriptorsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkWriteResourceDescriptorsEXT.html)"]
pub unsafe fn write_resource_descriptors_ext(
	device: &Device,
	resource_count: u32,
	p_resources: *const vk::ResourceDescriptorInfoEXT<'_>,
	p_descriptors: *const vk::HostAddressRangeEXT<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.write_resource_descriptors_ext
		.ok_or(CallError::MissingCommand("vkWriteResourceDescriptorsEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result =
		unsafe { __vk_function(device.handle(), resource_count, p_resources, p_descriptors) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkWriteResourceDescriptorsEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkWriteResourceDescriptorsEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkWriteResourceDescriptorsEXT")]
	#[doc = "\n\n[Khronos reference: `vkWriteResourceDescriptorsEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkWriteResourceDescriptorsEXT.html)"]
	#[inline]
	pub unsafe fn write_resource_descriptors_ext(
		&self,
		resource_count: u32,
		p_resources: *const vk::ResourceDescriptorInfoEXT<'_>,
		p_descriptors: *const vk::HostAddressRangeEXT<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { write_resource_descriptors_ext(self, resource_count, p_resources, p_descriptors) }
	}
}

/// Call `vkCmdBindSamplerHeapEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindSamplerHeapEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBindSamplerHeapEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdBindSamplerHeapEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindSamplerHeapEXT.html)"]
pub unsafe fn cmd_bind_sampler_heap_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_bind_info: *const vk::BindHeapInfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_sampler_heap_ext
		.ok_or(CallError::MissingCommand("vkCmdBindSamplerHeapEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_bind_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBindSamplerHeapEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindSamplerHeapEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBindSamplerHeapEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindSamplerHeapEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindSamplerHeapEXT.html)"]
	#[inline]
	pub unsafe fn cmd_bind_sampler_heap_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_bind_info: *const vk::BindHeapInfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_bind_sampler_heap_ext(self, command_buffer, p_bind_info) }
	}
}

/// Call `vkCmdBindResourceHeapEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindResourceHeapEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBindResourceHeapEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdBindResourceHeapEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindResourceHeapEXT.html)"]
pub unsafe fn cmd_bind_resource_heap_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_bind_info: *const vk::BindHeapInfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_resource_heap_ext
		.ok_or(CallError::MissingCommand("vkCmdBindResourceHeapEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_bind_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBindResourceHeapEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindResourceHeapEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBindResourceHeapEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindResourceHeapEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindResourceHeapEXT.html)"]
	#[inline]
	pub unsafe fn cmd_bind_resource_heap_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_bind_info: *const vk::BindHeapInfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_bind_resource_heap_ext(self, command_buffer, p_bind_info) }
	}
}

/// Call `vkCmdPushDataEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdPushDataEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdPushDataEXT")]
#[doc = "\n\n[Khronos reference: `vkCmdPushDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushDataEXT.html)"]
pub unsafe fn cmd_push_data_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_push_data_info: *const vk::PushDataInfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_push_data_ext
		.ok_or(CallError::MissingCommand("vkCmdPushDataEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_push_data_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdPushDataEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdPushDataEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdPushDataEXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdPushDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdPushDataEXT.html)"]
	#[inline]
	pub unsafe fn cmd_push_data_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_push_data_info: *const vk::PushDataInfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_push_data_ext(self, command_buffer, p_push_data_info) }
	}
}

/// Call `vkRegisterCustomBorderColorEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkRegisterCustomBorderColorEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkRegisterCustomBorderColorEXT")]
#[doc = "\n\n[Khronos reference: `vkRegisterCustomBorderColorEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkRegisterCustomBorderColorEXT.html)"]
pub unsafe fn register_custom_border_color_ext(
	device: &Device,
	p_border_color: *const vk::SamplerCustomBorderColorCreateInfoEXT<'_>,
	request_index: vk::Bool32,
	p_index: *mut u32,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.register_custom_border_color_ext
		.ok_or(CallError::MissingCommand("vkRegisterCustomBorderColorEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), p_border_color, request_index, p_index) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkRegisterCustomBorderColorEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkRegisterCustomBorderColorEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkRegisterCustomBorderColorEXT")]
	#[doc = "\n\n[Khronos reference: `vkRegisterCustomBorderColorEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkRegisterCustomBorderColorEXT.html)"]
	#[inline]
	pub unsafe fn register_custom_border_color_ext(
		&self,
		p_border_color: *const vk::SamplerCustomBorderColorCreateInfoEXT<'_>,
		request_index: vk::Bool32,
		p_index: *mut u32,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { register_custom_border_color_ext(self, p_border_color, request_index, p_index) }
	}
}

/// Call `vkUnregisterCustomBorderColorEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkUnregisterCustomBorderColorEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkUnregisterCustomBorderColorEXT")]
#[doc = "\n\n[Khronos reference: `vkUnregisterCustomBorderColorEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkUnregisterCustomBorderColorEXT.html)"]
pub unsafe fn unregister_custom_border_color_ext(
	device: &Device,
	index: u32,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.unregister_custom_border_color_ext
			.ok_or(CallError::MissingCommand(
				"vkUnregisterCustomBorderColorEXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(device.handle(), index) };
	Ok(())
}

impl Device {
	/// Call `vkUnregisterCustomBorderColorEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkUnregisterCustomBorderColorEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkUnregisterCustomBorderColorEXT")]
	#[doc = "\n\n[Khronos reference: `vkUnregisterCustomBorderColorEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkUnregisterCustomBorderColorEXT.html)"]
	#[inline]
	pub unsafe fn unregister_custom_border_color_ext(&self, index: u32) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { unregister_custom_border_color_ext(self, index) }
	}
}

/// Call `vkGetImageOpaqueCaptureDataEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetImageOpaqueCaptureDataEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetImageOpaqueCaptureDataEXT")]
#[doc = "\n\n[Khronos reference: `vkGetImageOpaqueCaptureDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageOpaqueCaptureDataEXT.html)"]
pub unsafe fn get_image_opaque_capture_data_ext(
	device: &Device,
	image_count: u32,
	p_images: *const vk::Image,
	p_datas: *mut vk::HostAddressRangeEXT<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_image_opaque_capture_data_ext
		.ok_or(CallError::MissingCommand("vkGetImageOpaqueCaptureDataEXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), image_count, p_images, p_datas) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetImageOpaqueCaptureDataEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetImageOpaqueCaptureDataEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetImageOpaqueCaptureDataEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetImageOpaqueCaptureDataEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetImageOpaqueCaptureDataEXT.html)"]
	#[inline]
	pub unsafe fn get_image_opaque_capture_data_ext(
		&self,
		image_count: u32,
		p_images: *const vk::Image,
		p_datas: *mut vk::HostAddressRangeEXT<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_image_opaque_capture_data_ext(self, image_count, p_images, p_datas) }
	}
}

/// Call `vkGetPhysicalDeviceDescriptorSizeEXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceDescriptorSizeEXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceDescriptorSizeEXT")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceDescriptorSizeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceDescriptorSizeEXT.html)"]
pub unsafe fn get_physical_device_descriptor_size_ext(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	descriptor_type: vk::DescriptorType,
) -> Result<vk::DeviceSize, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_descriptor_size_ext
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceDescriptorSizeEXT",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(physical_device, descriptor_type) };
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceDescriptorSizeEXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceDescriptorSizeEXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceDescriptorSizeEXT")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceDescriptorSizeEXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceDescriptorSizeEXT.html)"]
	#[inline]
	pub unsafe fn get_physical_device_descriptor_size_ext(
		&self,
		physical_device: vk::PhysicalDevice,
		descriptor_type: vk::DescriptorType,
	) -> Result<vk::DeviceSize, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_physical_device_descriptor_size_ext(self, physical_device, descriptor_type) }
	}
}

/// Call `vkGetTensorOpaqueCaptureDataARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetTensorOpaqueCaptureDataARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetTensorOpaqueCaptureDataARM")]
#[doc = "\n\n[Khronos reference: `vkGetTensorOpaqueCaptureDataARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetTensorOpaqueCaptureDataARM.html)"]
pub unsafe fn get_tensor_opaque_capture_data_arm(
	device: &Device,
	tensor_count: u32,
	p_tensors: *const vk::TensorARM,
	p_datas: *mut vk::HostAddressRangeEXT<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = device
		.fp()
		.get_tensor_opaque_capture_data_arm
		.ok_or(CallError::MissingCommand("vkGetTensorOpaqueCaptureDataARM"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe { __vk_function(device.handle(), tensor_count, p_tensors, p_datas) };
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkGetTensorOpaqueCaptureDataARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetTensorOpaqueCaptureDataARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetTensorOpaqueCaptureDataARM")]
	#[doc = "\n\n[Khronos reference: `vkGetTensorOpaqueCaptureDataARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetTensorOpaqueCaptureDataARM.html)"]
	#[inline]
	pub unsafe fn get_tensor_opaque_capture_data_arm(
		&self,
		tensor_count: u32,
		p_tensors: *const vk::TensorARM,
		p_datas: *mut vk::HostAddressRangeEXT<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { get_tensor_opaque_capture_data_arm(self, tensor_count, p_tensors, p_datas) }
	}
}

/// Call `vkCmdCopyMemoryKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyMemoryKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdCopyMemoryKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyMemoryKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyMemoryKHR.html)"]
pub unsafe fn cmd_copy_memory_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_copy_memory_info: *const vk::CopyDeviceMemoryInfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_memory_khr
		.ok_or(CallError::MissingCommand("vkCmdCopyMemoryKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_copy_memory_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyMemoryKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyMemoryKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdCopyMemoryKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyMemoryKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyMemoryKHR.html)"]
	#[inline]
	pub unsafe fn cmd_copy_memory_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_copy_memory_info: *const vk::CopyDeviceMemoryInfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_memory_khr(self, command_buffer, p_copy_memory_info) }
	}
}

/// Call `vkCmdCopyMemoryToImageKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyMemoryToImageKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdCopyMemoryToImageKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyMemoryToImageKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyMemoryToImageKHR.html)"]
pub unsafe fn cmd_copy_memory_to_image_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_copy_memory_info: *const vk::CopyDeviceMemoryImageInfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_memory_to_image_khr
		.ok_or(CallError::MissingCommand("vkCmdCopyMemoryToImageKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_copy_memory_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyMemoryToImageKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyMemoryToImageKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdCopyMemoryToImageKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyMemoryToImageKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyMemoryToImageKHR.html)"]
	#[inline]
	pub unsafe fn cmd_copy_memory_to_image_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_copy_memory_info: *const vk::CopyDeviceMemoryImageInfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_memory_to_image_khr(self, command_buffer, p_copy_memory_info) }
	}
}

/// Call `vkCmdCopyImageToMemoryKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyImageToMemoryKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdCopyImageToMemoryKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyImageToMemoryKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyImageToMemoryKHR.html)"]
pub unsafe fn cmd_copy_image_to_memory_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_copy_memory_info: *const vk::CopyDeviceMemoryImageInfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_image_to_memory_khr
		.ok_or(CallError::MissingCommand("vkCmdCopyImageToMemoryKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_copy_memory_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyImageToMemoryKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyImageToMemoryKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdCopyImageToMemoryKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyImageToMemoryKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyImageToMemoryKHR.html)"]
	#[inline]
	pub unsafe fn cmd_copy_image_to_memory_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_copy_memory_info: *const vk::CopyDeviceMemoryImageInfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_copy_image_to_memory_khr(self, command_buffer, p_copy_memory_info) }
	}
}

/// Call `vkCmdUpdateMemoryKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdUpdateMemoryKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdUpdateMemoryKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdUpdateMemoryKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdUpdateMemoryKHR.html)"]
pub unsafe fn cmd_update_memory_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_dst_range: *const vk::DeviceAddressRangeKHR,
	dst_flags: vk::AddressCommandFlagsKHR,
	data_size: vk::DeviceSize,
	p_data: *const std::ffi::c_void,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_update_memory_khr
		.ok_or(CallError::MissingCommand("vkCmdUpdateMemoryKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_dst_range, dst_flags, data_size, p_data) };
	Ok(())
}

impl Device {
	/// Call `vkCmdUpdateMemoryKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdUpdateMemoryKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdUpdateMemoryKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdUpdateMemoryKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdUpdateMemoryKHR.html)"]
	#[inline]
	pub unsafe fn cmd_update_memory_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_dst_range: *const vk::DeviceAddressRangeKHR,
		dst_flags: vk::AddressCommandFlagsKHR,
		data_size: vk::DeviceSize,
		p_data: *const std::ffi::c_void,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_update_memory_khr(
				self,
				command_buffer,
				p_dst_range,
				dst_flags,
				data_size,
				p_data,
			)
		}
	}
}

/// Call `vkCmdFillMemoryKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdFillMemoryKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdFillMemoryKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdFillMemoryKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdFillMemoryKHR.html)"]
pub unsafe fn cmd_fill_memory_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_dst_range: *const vk::DeviceAddressRangeKHR,
	dst_flags: vk::AddressCommandFlagsKHR,
	data: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_fill_memory_khr
		.ok_or(CallError::MissingCommand("vkCmdFillMemoryKHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_dst_range, dst_flags, data) };
	Ok(())
}

impl Device {
	/// Call `vkCmdFillMemoryKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdFillMemoryKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdFillMemoryKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdFillMemoryKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdFillMemoryKHR.html)"]
	#[inline]
	pub unsafe fn cmd_fill_memory_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_dst_range: *const vk::DeviceAddressRangeKHR,
		dst_flags: vk::AddressCommandFlagsKHR,
		data: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_fill_memory_khr(self, command_buffer, p_dst_range, dst_flags, data) }
	}
}

/// Call `vkCmdCopyQueryPoolResultsToMemoryKHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdCopyQueryPoolResultsToMemoryKHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdCopyQueryPoolResultsToMemoryKHR")]
#[doc = "\n\n[Khronos reference: `vkCmdCopyQueryPoolResultsToMemoryKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyQueryPoolResultsToMemoryKHR.html)"]
#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
pub unsafe fn cmd_copy_query_pool_results_to_memory_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	query_pool: vk::QueryPool,
	first_query: u32,
	query_count: u32,
	p_dst_range: *const vk::StridedDeviceAddressRangeKHR,
	dst_flags: vk::AddressCommandFlagsKHR,
	query_result_flags: vk::QueryResultFlags,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_copy_query_pool_results_to_memory_khr
		.ok_or(CallError::MissingCommand(
			"vkCmdCopyQueryPoolResultsToMemoryKHR",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			query_pool,
			first_query,
			query_count,
			p_dst_range,
			dst_flags,
			query_result_flags,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdCopyQueryPoolResultsToMemoryKHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdCopyQueryPoolResultsToMemoryKHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdCopyQueryPoolResultsToMemoryKHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdCopyQueryPoolResultsToMemoryKHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdCopyQueryPoolResultsToMemoryKHR.html)"]
	#[allow(clippy::too_many_arguments)] // Preserve the native operation's parameter groups.
	#[inline]
	pub unsafe fn cmd_copy_query_pool_results_to_memory_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		query_pool: vk::QueryPool,
		first_query: u32,
		query_count: u32,
		p_dst_range: *const vk::StridedDeviceAddressRangeKHR,
		dst_flags: vk::AddressCommandFlagsKHR,
		query_result_flags: vk::QueryResultFlags,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_copy_query_pool_results_to_memory_khr(
				self,
				command_buffer,
				query_pool,
				first_query,
				query_count,
				p_dst_range,
				dst_flags,
				query_result_flags,
			)
		}
	}
}

/// Call `vkCmdBeginConditionalRendering2EXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBeginConditionalRendering2EXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBeginConditionalRendering2EXT")]
#[doc = "\n\n[Khronos reference: `vkCmdBeginConditionalRendering2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginConditionalRendering2EXT.html)"]
pub unsafe fn cmd_begin_conditional_rendering2_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_conditional_rendering_begin: *const vk::ConditionalRenderingBeginInfo2EXT<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_begin_conditional_rendering2_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdBeginConditionalRendering2EXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_conditional_rendering_begin) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBeginConditionalRendering2EXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBeginConditionalRendering2EXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBeginConditionalRendering2EXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdBeginConditionalRendering2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginConditionalRendering2EXT.html)"]
	#[inline]
	pub unsafe fn cmd_begin_conditional_rendering2_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_conditional_rendering_begin: *const vk::ConditionalRenderingBeginInfo2EXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_begin_conditional_rendering2_ext(self, command_buffer, p_conditional_rendering_begin)
		}
	}
}

/// Call `vkCmdBindTransformFeedbackBuffers2EXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindTransformFeedbackBuffers2EXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBindTransformFeedbackBuffers2EXT")]
#[doc = "\n\n[Khronos reference: `vkCmdBindTransformFeedbackBuffers2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindTransformFeedbackBuffers2EXT.html)"]
pub unsafe fn cmd_bind_transform_feedback_buffers2_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_binding: u32,
	binding_count: u32,
	p_binding_infos: *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_bind_transform_feedback_buffers2_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdBindTransformFeedbackBuffers2EXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_binding,
			binding_count,
			p_binding_infos,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdBindTransformFeedbackBuffers2EXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindTransformFeedbackBuffers2EXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBindTransformFeedbackBuffers2EXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindTransformFeedbackBuffers2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindTransformFeedbackBuffers2EXT.html)"]
	#[inline]
	pub unsafe fn cmd_bind_transform_feedback_buffers2_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		first_binding: u32,
		binding_count: u32,
		p_binding_infos: *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_bind_transform_feedback_buffers2_ext(
				self,
				command_buffer,
				first_binding,
				binding_count,
				p_binding_infos,
			)
		}
	}
}

/// Call `vkCmdBeginTransformFeedback2EXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBeginTransformFeedback2EXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBeginTransformFeedback2EXT")]
#[doc = "\n\n[Khronos reference: `vkCmdBeginTransformFeedback2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginTransformFeedback2EXT.html)"]
pub unsafe fn cmd_begin_transform_feedback2_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_counter_range: u32,
	counter_range_count: u32,
	p_counter_infos: *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_begin_transform_feedback2_ext
		.ok_or(CallError::MissingCommand("vkCmdBeginTransformFeedback2EXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_counter_range,
			counter_range_count,
			p_counter_infos,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdBeginTransformFeedback2EXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBeginTransformFeedback2EXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBeginTransformFeedback2EXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdBeginTransformFeedback2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBeginTransformFeedback2EXT.html)"]
	#[inline]
	pub unsafe fn cmd_begin_transform_feedback2_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		first_counter_range: u32,
		counter_range_count: u32,
		p_counter_infos: *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_begin_transform_feedback2_ext(
				self,
				command_buffer,
				first_counter_range,
				counter_range_count,
				p_counter_infos,
			)
		}
	}
}

/// Call `vkCmdEndTransformFeedback2EXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdEndTransformFeedback2EXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdEndTransformFeedback2EXT")]
#[doc = "\n\n[Khronos reference: `vkCmdEndTransformFeedback2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndTransformFeedback2EXT.html)"]
pub unsafe fn cmd_end_transform_feedback2_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_counter_range: u32,
	counter_range_count: u32,
	p_counter_infos: *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_end_transform_feedback2_ext
		.ok_or(CallError::MissingCommand("vkCmdEndTransformFeedback2EXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_counter_range,
			counter_range_count,
			p_counter_infos,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdEndTransformFeedback2EXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdEndTransformFeedback2EXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdEndTransformFeedback2EXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdEndTransformFeedback2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdEndTransformFeedback2EXT.html)"]
	#[inline]
	pub unsafe fn cmd_end_transform_feedback2_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		first_counter_range: u32,
		counter_range_count: u32,
		p_counter_infos: *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_end_transform_feedback2_ext(
				self,
				command_buffer,
				first_counter_range,
				counter_range_count,
				p_counter_infos,
			)
		}
	}
}

/// Call `vkCmdDrawIndirectByteCount2EXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawIndirectByteCount2EXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDrawIndirectByteCount2EXT")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawIndirectByteCount2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndirectByteCount2EXT.html)"]
pub unsafe fn cmd_draw_indirect_byte_count2_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	instance_count: u32,
	first_instance: u32,
	p_counter_info: *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
	counter_offset: u32,
	vertex_stride: u32,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_indirect_byte_count2_ext
		.ok_or(CallError::MissingCommand("vkCmdDrawIndirectByteCount2EXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			instance_count,
			first_instance,
			p_counter_info,
			counter_offset,
			vertex_stride,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawIndirectByteCount2EXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawIndirectByteCount2EXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDrawIndirectByteCount2EXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawIndirectByteCount2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndirectByteCount2EXT.html)"]
	#[inline]
	pub unsafe fn cmd_draw_indirect_byte_count2_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		instance_count: u32,
		first_instance: u32,
		p_counter_info: *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
		counter_offset: u32,
		vertex_stride: u32,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_draw_indirect_byte_count2_ext(
				self,
				command_buffer,
				instance_count,
				first_instance,
				p_counter_info,
				counter_offset,
				vertex_stride,
			)
		}
	}
}

/// Call `vkCmdWriteMarkerToMemoryAMD` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdWriteMarkerToMemoryAMD` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdWriteMarkerToMemoryAMD")]
#[doc = "\n\n[Khronos reference: `vkCmdWriteMarkerToMemoryAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWriteMarkerToMemoryAMD.html)"]
pub unsafe fn cmd_write_marker_to_memory_amd(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_info: *const vk::MemoryMarkerInfoAMD<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_write_marker_to_memory_amd
		.ok_or(CallError::MissingCommand("vkCmdWriteMarkerToMemoryAMD"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdWriteMarkerToMemoryAMD` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdWriteMarkerToMemoryAMD` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdWriteMarkerToMemoryAMD")]
	#[doc = "\n\n[Khronos reference: `vkCmdWriteMarkerToMemoryAMD`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdWriteMarkerToMemoryAMD.html)"]
	#[inline]
	pub unsafe fn cmd_write_marker_to_memory_amd(
		&self,
		command_buffer: vk::CommandBuffer,
		p_info: *const vk::MemoryMarkerInfoAMD<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_write_marker_to_memory_amd(self, command_buffer, p_info) }
	}
}

/// Call `vkCmdBindIndexBuffer3KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindIndexBuffer3KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBindIndexBuffer3KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdBindIndexBuffer3KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindIndexBuffer3KHR.html)"]
pub unsafe fn cmd_bind_index_buffer3_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_info: *const vk::BindIndexBuffer3InfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_index_buffer3_khr
		.ok_or(CallError::MissingCommand("vkCmdBindIndexBuffer3KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdBindIndexBuffer3KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindIndexBuffer3KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBindIndexBuffer3KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindIndexBuffer3KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindIndexBuffer3KHR.html)"]
	#[inline]
	pub unsafe fn cmd_bind_index_buffer3_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_info: *const vk::BindIndexBuffer3InfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_bind_index_buffer3_khr(self, command_buffer, p_info) }
	}
}

/// Call `vkCmdBindVertexBuffers3KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdBindVertexBuffers3KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdBindVertexBuffers3KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdBindVertexBuffers3KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindVertexBuffers3KHR.html)"]
pub unsafe fn cmd_bind_vertex_buffers3_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	first_binding: u32,
	binding_count: u32,
	p_binding_infos: *const vk::BindVertexBuffer3InfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_bind_vertex_buffers3_khr
		.ok_or(CallError::MissingCommand("vkCmdBindVertexBuffers3KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe {
		__vk_function(
			command_buffer,
			first_binding,
			binding_count,
			p_binding_infos,
		)
	};
	Ok(())
}

impl Device {
	/// Call `vkCmdBindVertexBuffers3KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdBindVertexBuffers3KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdBindVertexBuffers3KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdBindVertexBuffers3KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdBindVertexBuffers3KHR.html)"]
	#[inline]
	pub unsafe fn cmd_bind_vertex_buffers3_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		first_binding: u32,
		binding_count: u32,
		p_binding_infos: *const vk::BindVertexBuffer3InfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			cmd_bind_vertex_buffers3_khr(
				self,
				command_buffer,
				first_binding,
				binding_count,
				p_binding_infos,
			)
		}
	}
}

/// Call `vkCmdDrawIndirect2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawIndirect2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDrawIndirect2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawIndirect2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndirect2KHR.html)"]
pub unsafe fn cmd_draw_indirect2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_info: *const vk::DrawIndirect2InfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_indirect2_khr
		.ok_or(CallError::MissingCommand("vkCmdDrawIndirect2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawIndirect2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawIndirect2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDrawIndirect2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawIndirect2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndirect2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_draw_indirect2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_info: *const vk::DrawIndirect2InfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_draw_indirect2_khr(self, command_buffer, p_info) }
	}
}

/// Call `vkCmdDrawIndexedIndirect2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawIndexedIndirect2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDrawIndexedIndirect2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawIndexedIndirect2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndexedIndirect2KHR.html)"]
pub unsafe fn cmd_draw_indexed_indirect2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_info: *const vk::DrawIndirect2InfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_indexed_indirect2_khr
		.ok_or(CallError::MissingCommand("vkCmdDrawIndexedIndirect2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawIndexedIndirect2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawIndexedIndirect2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDrawIndexedIndirect2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawIndexedIndirect2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndexedIndirect2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_draw_indexed_indirect2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_info: *const vk::DrawIndirect2InfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_draw_indexed_indirect2_khr(self, command_buffer, p_info) }
	}
}

/// Call `vkCmdDrawIndirectCount2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawIndirectCount2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDrawIndirectCount2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawIndirectCount2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndirectCount2KHR.html)"]
pub unsafe fn cmd_draw_indirect_count2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_info: *const vk::DrawIndirectCount2InfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_indirect_count2_khr
		.ok_or(CallError::MissingCommand("vkCmdDrawIndirectCount2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawIndirectCount2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawIndirectCount2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDrawIndirectCount2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawIndirectCount2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndirectCount2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_draw_indirect_count2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_info: *const vk::DrawIndirectCount2InfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_draw_indirect_count2_khr(self, command_buffer, p_info) }
	}
}

/// Call `vkCmdDrawIndexedIndirectCount2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawIndexedIndirectCount2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDrawIndexedIndirectCount2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawIndexedIndirectCount2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndexedIndirectCount2KHR.html)"]
pub unsafe fn cmd_draw_indexed_indirect_count2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_info: *const vk::DrawIndirectCount2InfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_draw_indexed_indirect_count2_khr
			.ok_or(CallError::MissingCommand(
				"vkCmdDrawIndexedIndirectCount2KHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawIndexedIndirectCount2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawIndexedIndirectCount2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDrawIndexedIndirectCount2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawIndexedIndirectCount2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawIndexedIndirectCount2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_draw_indexed_indirect_count2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_info: *const vk::DrawIndirectCount2InfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_draw_indexed_indirect_count2_khr(self, command_buffer, p_info) }
	}
}

/// Call `vkCmdDrawMeshTasksIndirect2EXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawMeshTasksIndirect2EXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDrawMeshTasksIndirect2EXT")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawMeshTasksIndirect2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawMeshTasksIndirect2EXT.html)"]
pub unsafe fn cmd_draw_mesh_tasks_indirect2_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_info: *const vk::DrawIndirect2InfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_draw_mesh_tasks_indirect2_ext
		.ok_or(CallError::MissingCommand("vkCmdDrawMeshTasksIndirect2EXT"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawMeshTasksIndirect2EXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawMeshTasksIndirect2EXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDrawMeshTasksIndirect2EXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawMeshTasksIndirect2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawMeshTasksIndirect2EXT.html)"]
	#[inline]
	pub unsafe fn cmd_draw_mesh_tasks_indirect2_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_info: *const vk::DrawIndirect2InfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_draw_mesh_tasks_indirect2_ext(self, command_buffer, p_info) }
	}
}

/// Call `vkCmdDrawMeshTasksIndirectCount2EXT` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDrawMeshTasksIndirectCount2EXT` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDrawMeshTasksIndirectCount2EXT")]
#[doc = "\n\n[Khronos reference: `vkCmdDrawMeshTasksIndirectCount2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawMeshTasksIndirectCount2EXT.html)"]
pub unsafe fn cmd_draw_mesh_tasks_indirect_count2_ext(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_info: *const vk::DrawIndirectCount2InfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function =
		device
			.fp()
			.cmd_draw_mesh_tasks_indirect_count2_ext
			.ok_or(CallError::MissingCommand(
				"vkCmdDrawMeshTasksIndirectCount2EXT",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDrawMeshTasksIndirectCount2EXT` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDrawMeshTasksIndirectCount2EXT` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDrawMeshTasksIndirectCount2EXT")]
	#[doc = "\n\n[Khronos reference: `vkCmdDrawMeshTasksIndirectCount2EXT`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDrawMeshTasksIndirectCount2EXT.html)"]
	#[inline]
	pub unsafe fn cmd_draw_mesh_tasks_indirect_count2_ext(
		&self,
		command_buffer: vk::CommandBuffer,
		p_info: *const vk::DrawIndirectCount2InfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_draw_mesh_tasks_indirect_count2_ext(self, command_buffer, p_info) }
	}
}

/// Call `vkCmdDispatchIndirect2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdDispatchIndirect2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdDispatchIndirect2KHR")]
#[doc = "\n\n[Khronos reference: `vkCmdDispatchIndirect2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDispatchIndirect2KHR.html)"]
pub unsafe fn cmd_dispatch_indirect2_khr(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_info: *const vk::DispatchIndirect2InfoKHR<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_dispatch_indirect2_khr
		.ok_or(CallError::MissingCommand("vkCmdDispatchIndirect2KHR"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_info) };
	Ok(())
}

impl Device {
	/// Call `vkCmdDispatchIndirect2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdDispatchIndirect2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdDispatchIndirect2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCmdDispatchIndirect2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdDispatchIndirect2KHR.html)"]
	#[inline]
	pub unsafe fn cmd_dispatch_indirect2_khr(
		&self,
		command_buffer: vk::CommandBuffer,
		p_info: *const vk::DispatchIndirect2InfoKHR<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_dispatch_indirect2_khr(self, command_buffer, p_info) }
	}
}

/// Call `vkCreateAccelerationStructure2KHR` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCreateAccelerationStructure2KHR` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCreateAccelerationStructure2KHR")]
#[doc = "\n\n[Khronos reference: `vkCreateAccelerationStructure2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateAccelerationStructure2KHR.html)"]
pub unsafe fn create_acceleration_structure2_khr(
	device: &Device,
	p_create_info: *const vk::AccelerationStructureCreateInfo2KHR<'_>,
	p_allocator: *const vk::AllocationCallbacks,
	p_acceleration_structure: *mut vk::AccelerationStructureKHR,
) -> Result<vk::Result, CallError> {
	let __vk_function =
		device
			.fp()
			.create_acceleration_structure2_khr
			.ok_or(CallError::MissingCommand(
				"vkCreateAccelerationStructure2KHR",
			))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			device.handle(),
			p_create_info,
			p_allocator,
			p_acceleration_structure,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Device {
	/// Call `vkCreateAccelerationStructure2KHR` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCreateAccelerationStructure2KHR` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCreateAccelerationStructure2KHR")]
	#[doc = "\n\n[Khronos reference: `vkCreateAccelerationStructure2KHR`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCreateAccelerationStructure2KHR.html)"]
	#[inline]
	pub unsafe fn create_acceleration_structure2_khr(
		&self,
		p_create_info: *const vk::AccelerationStructureCreateInfo2KHR<'_>,
		p_allocator: *const vk::AllocationCallbacks,
		p_acceleration_structure: *mut vk::AccelerationStructureKHR,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			create_acceleration_structure2_khr(self, p_create_info, p_allocator, p_acceleration_structure)
		}
	}
}

/// Call `vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM.html)"]
pub unsafe fn get_physical_device_queue_family_data_graph_engine_operation_properties_arm(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	queue_family_index: u32,
	p_queue_family_data_graph_properties: *const vk::QueueFamilyDataGraphPropertiesARM<'_>,
	p_properties: *mut vk::BaseOutStructure<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_queue_family_data_graph_engine_operation_properties_arm
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			physical_device,
			queue_family_index,
			p_queue_family_data_graph_properties,
			p_properties,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM.html)"]
	#[inline]
	pub unsafe fn get_physical_device_queue_family_data_graph_engine_operation_properties_arm(
		&self,
		physical_device: vk::PhysicalDevice,
		queue_family_index: u32,
		p_queue_family_data_graph_properties: *const vk::QueueFamilyDataGraphPropertiesARM<'_>,
		p_properties: *mut vk::BaseOutStructure<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_queue_family_data_graph_engine_operation_properties_arm(
				self,
				physical_device,
				queue_family_index,
				p_queue_family_data_graph_properties,
				p_properties,
			)
		}
	}
}

/// Call `vkCmdSetDispatchParametersARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkCmdSetDispatchParametersARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkCmdSetDispatchParametersARM")]
#[doc = "\n\n[Khronos reference: `vkCmdSetDispatchParametersARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDispatchParametersARM.html)"]
pub unsafe fn cmd_set_dispatch_parameters_arm(
	device: &Device,
	command_buffer: vk::CommandBuffer,
	p_dispatch_parameters: *const vk::DispatchParametersARM<'_>,
) -> Result<(), CallError> {
	let __vk_function = device
		.fp()
		.cmd_set_dispatch_parameters_arm
		.ok_or(CallError::MissingCommand("vkCmdSetDispatchParametersARM"))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	unsafe { __vk_function(command_buffer, p_dispatch_parameters) };
	Ok(())
}

impl Device {
	/// Call `vkCmdSetDispatchParametersARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkCmdSetDispatchParametersARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkCmdSetDispatchParametersARM")]
	#[doc = "\n\n[Khronos reference: `vkCmdSetDispatchParametersARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkCmdSetDispatchParametersARM.html)"]
	#[inline]
	pub unsafe fn cmd_set_dispatch_parameters_arm(
		&self,
		command_buffer: vk::CommandBuffer,
		p_dispatch_parameters: *const vk::DispatchParametersARM<'_>,
	) -> Result<(), CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe { cmd_set_dispatch_parameters_arm(self, command_buffer, p_dispatch_parameters) }
	}
}

/// Call `vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM` using this context's cached function pointer.
///
/// # Errors
/// Reports a missing command or a negative native VkResult; non-error results are preserved.
///
/// # Safety
/// The context and all handles must be live and belong to the same Vulkan
/// implementation/device. Meet `vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM` valid usage, enabled API/extension/feature,
/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
/// requirements. Native resources require explicit destruction after completion.
///
/// Preserves native raw pointers, explicit counts, optional nulls and return values.
/// The caller supplies correctly aligned live storage, initialized output-chain
/// headers and every extent implied by native counts, strides or nested records.
/// No allocation, retry, output initialization, ownership transfer or alias fallback
/// occurs in this wrapper. Outputs, including partial outputs on native failure,
/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
#[doc(alias = "vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM")]
#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM.html)"]
pub unsafe fn get_physical_device_queue_family_data_graph_optical_flow_image_formats_arm(
	instance: &Instance,
	physical_device: vk::PhysicalDevice,
	queue_family_index: u32,
	p_queue_family_data_graph_properties: *const vk::QueueFamilyDataGraphPropertiesARM<'_>,
	p_optical_flow_image_format_info: *const vk::DataGraphOpticalFlowImageFormatInfoARM<'_>,
	p_format_count: *mut u32,
	p_image_format_properties: *mut vk::DataGraphOpticalFlowImageFormatPropertiesARM<'_>,
) -> Result<vk::Result, CallError> {
	let __vk_function = instance
		.fp()
		.get_physical_device_queue_family_data_graph_optical_flow_image_formats_arm
		.ok_or(CallError::MissingCommand(
			"vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM",
		))?;
	// SAFETY: the caller establishes the native valid-usage contract; argument validity and storage extents follow the documented operation contract.
	let result = unsafe {
		__vk_function(
			physical_device,
			queue_family_index,
			p_queue_family_data_graph_properties,
			p_optical_flow_image_format_info,
			p_format_count,
			p_image_format_properties,
		)
	};
	if result.is_err() {
		return Err(CallError::Vulkan(result));
	}
	Ok(result)
}

impl Instance {
	/// Call `vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM` using this context's cached function pointer.
	///
	/// # Errors
	/// Reports a missing command or a negative native VkResult; non-error results are preserved.
	///
	/// # Safety
	/// The context and all handles must be live and belong to the same Vulkan
	/// implementation/device. Meet `vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM` valid usage, enabled API/extension/feature,
	/// pointer-chain lifetime, callback compatibility and host/GPU synchronization
	/// requirements. Native resources require explicit destruction after completion.
	///
	/// Preserves native raw pointers, explicit counts, optional nulls and return values.
	/// The caller supplies correctly aligned live storage, initialized output-chain
	/// headers and every extent implied by native counts, strides or nested records.
	/// No allocation, retry, output initialization, ownership transfer or alias fallback
	/// occurs in this wrapper. Outputs, including partial outputs on native failure,
	/// remain caller-owned and must be inspected/cleaned up according to Vulkan.
	#[doc(alias = "vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM")]
	#[doc = "\n\n[Khronos reference: `vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM`](https://docs.vulkan.org/refpages/latest/refpages/source/vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM.html)"]
	#[inline]
	pub unsafe fn get_physical_device_queue_family_data_graph_optical_flow_image_formats_arm(
		&self,
		physical_device: vk::PhysicalDevice,
		queue_family_index: u32,
		p_queue_family_data_graph_properties: *const vk::QueueFamilyDataGraphPropertiesARM<'_>,
		p_optical_flow_image_format_info: *const vk::DataGraphOpticalFlowImageFormatInfoARM<'_>,
		p_format_count: *mut u32,
		p_image_format_properties: *mut vk::DataGraphOpticalFlowImageFormatPropertiesARM<'_>,
	) -> Result<vk::Result, CallError> {
		// SAFETY: the caller provides the canonical operation's native guarantees.
		unsafe {
			get_physical_device_queue_family_data_graph_optical_flow_image_formats_arm(
				self,
				physical_device,
				queue_family_index,
				p_queue_family_data_graph_properties,
				p_optical_flow_image_format_info,
				p_format_count,
				p_image_format_properties,
			)
		}
	}
}